home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 42 / Amiga Format AFCD42 (Issue 126, Aug 1999).iso / -serious- / programming / other / jikes / src / decl.cpp < prev    next >
C/C++ Source or Header  |  1999-05-14  |  182KB  |  4,371 lines
  1. // $Id: decl.cpp,v 1.15 1999/03/09 14:37:15 shields Exp $
  2. //
  3. // This software is subject to the terms of the IBM Jikes Compiler
  4. // License Agreement available at the following URL:
  5. // http://www.ibm.com/research/jikes.
  6. // Copyright (C) 1996, 1998, International Business Machines Corporation
  7. // and others.  All Rights Reserved.
  8. // You must accept the terms of that agreement to use this software.
  9. //
  10. #include "config.h"
  11. #include <sys/stat.h>
  12. #include "semantic.h"
  13. #include "control.h"
  14. #include "depend.h"
  15. #include "table.h"
  16. #include "tuple.h"
  17.  
  18. //
  19. // If this compilation unit contains a package declaration, make sure the package
  20. // is associated with a directory and that the name of the package is not also
  21. // associated with a type.
  22. //
  23. inline void Semantic::CheckPackage()
  24. {
  25.     if (compilation_unit -> package_declaration_opt)
  26.     {
  27.         //
  28.         // Make sure that the package actually exists.
  29.         //
  30.         if (this_package -> directory.Length() == 0 && control.option.directory == NULL)
  31.         {
  32.             ReportSemError(SemanticError::PACKAGE_NOT_FOUND,
  33.                            compilation_unit -> package_declaration_opt -> name -> LeftToken(),
  34.                            compilation_unit -> package_declaration_opt -> name -> RightToken(),
  35.                            this_package -> PackageName());
  36.         }
  37.         else
  38.         {
  39.             //
  40.             // Make sure that the package or any of its parents does not match the name of a type.
  41.             //
  42.             AstPackageDeclaration *package_declaration = compilation_unit -> package_declaration_opt;
  43.             AstExpression *name = FindFirstType(package_declaration -> name);
  44.             TypeSymbol *type = name -> symbol -> TypeCast();
  45.             if (type && (! type -> Bad()))
  46.             {
  47. assert(type -> file_symbol);
  48.                 char *file_name = type -> file_symbol -> FileName();
  49.                 int length = type -> file_symbol -> FileNameLength();
  50.                 wchar_t *error_name = new wchar_t[length + 1];
  51.                 for (int i = 0; i < length; i++)
  52.                     error_name[i] = file_name[i];
  53.                 error_name[length] = U_NULL;
  54.  
  55.                 ReportSemError(SemanticError::PACKAGE_TYPE_CONFLICT,
  56.                                name -> LeftToken(),
  57.                                name -> RightToken(),
  58.                                type -> ContainingPackage() -> PackageName(),
  59.                                type -> Name(),
  60.                                error_name);
  61.  
  62.                 delete [] error_name;
  63.             }
  64.         }
  65.     }
  66.  
  67.     return;
  68. }
  69.  
  70.  
  71. //
  72. // Pass 1: Introduce the main package, the current package and all types specified into their proper scope
  73. //
  74. void Semantic::ProcessTypeNames()
  75. {
  76.     import_on_demand_packages.Next() = control.system_package;
  77.     compilation_unit = source_file_symbol -> compilation_unit;
  78.  
  79.     //
  80.     // If we are supposed to be verbose, report empty declarations...
  81.     //
  82.     if (control.option.pedantic)
  83.     {
  84.         if (compilation_unit -> EmptyCompilationUnitCast())
  85.         {
  86.             ReportSemError(SemanticError::NO_TYPES,
  87.                            compilation_unit -> LeftToken(),
  88.                            compilation_unit -> RightToken());
  89.         }
  90.  
  91.         for (int i = 0; i < compilation_unit -> NumTypeDeclarations(); i++)
  92.         {
  93.             Ast *type_declaration = compilation_unit -> TypeDeclaration(i);
  94.             if (type_declaration -> EmptyDeclarationCast())
  95.             {
  96.                 ReportSemError(SemanticError::EMPTY_DECLARATION,
  97.                                type_declaration -> LeftToken(),
  98.                                type_declaration -> RightToken());
  99.             }
  100.         }
  101.     }
  102.  
  103.     //
  104.     // If we have a bad compilation unit insert its types as "bad types"
  105.     //
  106.     if (compilation_unit -> BadCompilationUnitCast())
  107.     {
  108.         for (int i = 0; i < lex_stream -> NumTypes(); i++)
  109.         {
  110.             LexStream::TokenIndex identifier_token = lex_stream -> Next(lex_stream -> Type(i));
  111.             if (lex_stream -> Kind(identifier_token) == TK_Identifier)
  112.             {
  113.                 NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  114.                 TypeSymbol *type = this_package -> FindTypeSymbol(name_symbol);
  115. assert(type);
  116.                 type -> MarkSourceNoLongerPending();
  117.                 type -> supertypes_closure = new SymbolSet;
  118.                 type -> subtypes = new SymbolSet;
  119.                 type -> semantic_environment = new SemanticEnvironment((Semantic *) this, type, NULL);
  120.                 if (type != control.Object())
  121.                     type -> super = (type == control.Throwable() ? control.Object() : control.Throwable());
  122.                 type -> MarkBad();
  123.                 AddDefaultConstructor(type);
  124.                 source_file_symbol -> types.Next() = type;
  125.             }
  126.         }
  127.  
  128.         return;
  129.     }
  130.  
  131.     //
  132.     // Process each type in this compilation unit, in turn
  133.     //
  134.     for (int k = 0; k < compilation_unit -> NumTypeDeclarations(); k++)
  135.     {
  136.         LexStream::TokenIndex identifier_token;
  137.         TypeSymbol *type = NULL;
  138.  
  139.         Ast *type_declaration = compilation_unit -> TypeDeclaration(k);
  140.         switch(type_declaration -> kind)
  141.         {
  142.             case Ast::CLASS:
  143.             {
  144.                 AstClassDeclaration *class_declaration = (AstClassDeclaration *) type_declaration;
  145.                 identifier_token = class_declaration -> identifier_token;
  146.                 NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  147.  
  148.                 type = this_package -> FindTypeSymbol(name_symbol);
  149.                 if (type)
  150.                 {
  151.                     if (! type -> SourcePending())
  152.                     {
  153.                         ReportSemError(SemanticError::DUPLICATE_TYPE_DECLARATION,
  154.                                        identifier_token,
  155.                                        identifier_token,
  156.                                        name_symbol -> Name(),
  157.                                        type -> FileLoc());
  158.                         type = NULL;
  159.                     }
  160.                     else
  161.                     {
  162.                         if (type -> ContainingPackage() == control.unnamed_package)
  163.                         {
  164.                             TypeSymbol *old_type = (TypeSymbol *) control.unnamed_package_types.Image(name_symbol);
  165.                             if (old_type != type)
  166.                             {
  167.                                 ReportSemError(SemanticError::DUPLICATE_TYPE_DECLARATION,
  168.                                                identifier_token,
  169.                                                identifier_token,
  170.                                                name_symbol -> Name(),
  171.                                                old_type -> FileLoc());
  172.                             }
  173.                         }
  174.  
  175.                         type -> MarkSourceNoLongerPending();
  176.                         type -> semantic_environment = new SemanticEnvironment((Semantic *) this, type, NULL);
  177.                         type -> supertypes_closure = new SymbolSet;
  178.                         type -> subtypes = new SymbolSet;
  179.                         type -> declaration = class_declaration;
  180.                         type -> SetFlags(ProcessClassModifiers(class_declaration));
  181.                         //
  182.                         // Add 3 extra elements for padding. May need a default constructor and other support elements.
  183.                         //
  184.                         type -> SetSymbolTable(class_declaration -> class_body -> NumClassBodyDeclarations() + 3);
  185.                         type -> SetLocation();
  186.  
  187.                         source_file_symbol -> types.Next() = type;
  188.                         class_declaration -> semantic_environment = type -> semantic_environment; // save for processing bodies later.
  189.  
  190.                         CheckClassMembers(type, class_declaration -> class_body);
  191.                     }
  192.                 }
  193.  
  194.                 break;
  195.             }
  196.             case Ast::INTERFACE:
  197.             {
  198.                 AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) type_declaration;
  199.                 identifier_token = interface_declaration -> identifier_token;
  200.                 NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  201.  
  202.                 type = this_package -> FindTypeSymbol(name_symbol);
  203.                 if (type)
  204.                 {
  205.                     if (! type -> SourcePending())
  206.                     {
  207.                         ReportSemError(SemanticError::DUPLICATE_TYPE_DECLARATION,
  208.                                        identifier_token,
  209.                                        identifier_token,
  210.                                        name_symbol -> Name(),
  211.                                        type -> FileLoc());
  212.                         type = NULL;
  213.                     }
  214.                     else
  215.                     {
  216.                         if (type -> ContainingPackage() == control.unnamed_package)
  217.                         {
  218.                             TypeSymbol *old_type = (TypeSymbol *) control.unnamed_package_types.Image(name_symbol);
  219.                             if (old_type != type)
  220.                             {
  221.                                 ReportSemError(SemanticError::DUPLICATE_TYPE_DECLARATION,
  222.                                                identifier_token,
  223.                                                identifier_token,
  224.                                                name_symbol -> Name(),
  225.                                                old_type -> FileLoc());
  226.                             }
  227.                         }
  228.  
  229.                         type -> MarkSourceNoLongerPending();
  230.                         type -> semantic_environment = new SemanticEnvironment((Semantic *) this, type, NULL);
  231.                         type -> supertypes_closure = new SymbolSet;
  232.                         type -> subtypes = new SymbolSet;
  233.                         type -> declaration = interface_declaration;
  234.                         type -> file_symbol = source_file_symbol;
  235.                         type -> SetFlags(ProcessInterfaceModifiers(interface_declaration));
  236.                         type -> SetSymbolTable(interface_declaration -> NumInterfaceMemberDeclarations());
  237.                         type -> SetLocation();
  238.  
  239.                         source_file_symbol -> types.Next() = type;
  240.                         interface_declaration -> semantic_environment = type -> semantic_environment;
  241.  
  242.                         CheckInterfaceMembers(type, interface_declaration);
  243.                     }
  244.                 }
  245.                 break;
  246.             }
  247.         }
  248.  
  249.         //
  250.         // If we successfully processed this type, check that
  251.         //     . its name does not conflict with a subpackage
  252.         //     . if it is contained in a file with a diffent name
  253.         //       than its own name that there does not also exist a
  254.         //       (java or class) file with its name.
  255.         //
  256.         if (type)
  257.         {
  258.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  259.             for (int i = 0; i < this_package -> directory.Length(); i++)
  260.             {
  261.                 if (this_package -> directory[i] -> FindDirectorySymbol(name_symbol))
  262.                 {
  263.                     char *file_name = type -> file_symbol -> FileName();
  264.                     int length = type -> file_symbol -> FileNameLength();
  265.                     wchar_t *error_name = new wchar_t[length + 1];
  266.                     for (int j = 0; j < length; j++)
  267.                         error_name[j] = file_name[j];
  268.                     error_name[length] = U_NULL;
  269.  
  270.                     ReportSemError(SemanticError::PACKAGE_TYPE_CONFLICT,
  271.                                    identifier_token,
  272.                                    identifier_token,
  273.                                    this_package -> PackageName(),
  274.                                    name_symbol -> Name(),
  275.                                    error_name);
  276.  
  277.                     delete [] error_name;
  278.                 }
  279.             }
  280.  
  281.             if (type -> Identity() != source_file_symbol -> Identity())
  282.             {
  283.                 PackageSymbol *package = this_package;
  284.                 FileSymbol *file_symbol = Control::GetJavaFile(package, type -> Identity());
  285.  
  286.                 if (file_symbol)
  287.                 {
  288.                     ReportSemError(SemanticError::TYPE_IN_MULTIPLE_FILES,
  289.                                    identifier_token,
  290.                                    identifier_token,
  291.                                    this_package -> PackageName(),
  292.                                    source_file_symbol -> Name(),
  293.                                    package -> PackageName(),
  294.                                    type -> Name());
  295.                 }
  296.             }
  297.         }
  298.     }
  299.  
  300.     CheckPackage();
  301.     ProcessImports();
  302.     ProcessSuperTypes();
  303.  
  304.     return;
  305. }
  306.  
  307.  
  308. void Semantic::CheckClassMembers(TypeSymbol *containing_type, AstClassBody *class_body)
  309. {
  310.     for (int i = 0; i < class_body -> NumNestedClasses(); i++)
  311.     {
  312.         AstClassDeclaration *class_declaration = class_body -> NestedClass(i);
  313.  
  314.         if (! control.option.one_one)
  315.         {
  316.              ReportSemError(SemanticError::ONE_ONE_FEATURE,
  317.                             class_declaration -> LeftToken(),
  318.                             class_declaration -> RightToken());
  319.         }
  320.  
  321.         ProcessNestedClassName(containing_type, class_declaration);
  322.     }
  323.  
  324.     for (int j = 0; j < class_body -> NumNestedInterfaces(); j++)
  325.     {
  326.         AstInterfaceDeclaration *interface_declaration = class_body -> NestedInterface(j);
  327.  
  328.         if (! control.option.one_one)
  329.         {
  330.             ReportSemError(SemanticError::ONE_ONE_FEATURE,
  331.                            interface_declaration -> LeftToken(),
  332.                            interface_declaration -> RightToken());
  333.         }
  334.  
  335.         ProcessNestedInterfaceName(containing_type, interface_declaration);
  336.     }
  337.  
  338.     for (int k = 0; k < class_body -> NumBlocks(); k++)
  339.     {
  340.         if (! control.option.one_one)
  341.         {
  342.             ReportSemError(SemanticError::ONE_ONE_FEATURE,
  343.                            class_body -> Block(k) -> LeftToken(),
  344.                            class_body -> Block(k) -> RightToken());
  345.         }
  346.     }
  347.  
  348.     for (int l = 0; l < class_body -> NumEmptyDeclarations(); l++)
  349.     {
  350.         if (control.option.pedantic)
  351.         {
  352.             ReportSemError(SemanticError::EMPTY_DECLARATION,
  353.                            class_body -> EmptyDeclaration(l) -> LeftToken(),
  354.                            class_body -> EmptyDeclaration(l) -> RightToken());
  355.         }
  356.     }
  357.  
  358.     return;
  359. }
  360.  
  361.  
  362. inline TypeSymbol *Semantic::FindTypeInShadow(TypeShadowSymbol *type_shadow_symbol, LexStream::TokenIndex identifier_token)
  363. {
  364.     //
  365.     // Recall that even an inaccessible member x of a super class (or interface) S,
  366.     // in addition to not been inherited by a subclass, hides all other occurrences of x that may
  367.     // appear in a super class (or super interface) of S (see 8.3).
  368.     //
  369.     TypeSymbol *type_symbol = type_shadow_symbol -> type_symbol;
  370.  
  371.     for (int i = 0; i < type_shadow_symbol -> NumConflicts(); i++)
  372.     {
  373.         ReportSemError(SemanticError::AMBIGUOUS_NAME,
  374.                        identifier_token,
  375.                        identifier_token,
  376.                        type_symbol -> Name(),
  377.                        type_symbol -> owner -> TypeCast() -> ContainingPackage() -> PackageName(),
  378.                        type_symbol -> owner -> TypeCast() -> ExternalName(),
  379.                        type_shadow_symbol -> Conflict(i) -> owner -> TypeCast() -> ContainingPackage() -> PackageName(),
  380.                        type_shadow_symbol -> Conflict(i) -> owner -> TypeCast() -> ExternalName());
  381.     }
  382.  
  383.     return type_symbol;
  384. }
  385.  
  386.  
  387. //
  388. // Look for a type within an environment stack, without regard to inheritance !!!
  389. //
  390. TypeSymbol *Semantic::FindTypeInEnvironment(SemanticEnvironment *env_stack, NameSymbol *name_symbol)
  391. {
  392.     for (SemanticEnvironment *env = env_stack; env; env = env -> previous)
  393.     {
  394.         TypeSymbol *type = env -> symbol_table.FindTypeSymbol(name_symbol);
  395.         if (type)
  396.             return type;
  397.         type = env -> Type() -> FindTypeSymbol(name_symbol);
  398.         if (type)
  399.             return type;
  400.         if (name_symbol == env -> Type() -> Identity())
  401.             return env -> Type();
  402.     }
  403.  
  404.     return (TypeSymbol *) NULL;
  405. }
  406.  
  407.  
  408. void Semantic::CheckNestedTypeDuplication(SemanticEnvironment *env, LexStream::TokenIndex identifier_token)
  409. {
  410.     NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  411.  
  412.     //
  413.     // First check to see if we have a duplication at the same level...
  414.     //
  415.     TypeSymbol *old_type = (env -> symbol_table.Size() > 0 ? env -> symbol_table.Top() -> FindTypeSymbol(name_symbol)
  416.                                                            : env -> Type() -> FindTypeSymbol(name_symbol));
  417.     if (old_type)
  418.     {
  419.         ReportSemError(SemanticError::DUPLICATE_TYPE_DECLARATION,
  420.                        identifier_token,
  421.                        identifier_token,
  422.                        name_symbol -> Name(),
  423.                        old_type -> FileLoc());
  424.     }
  425.     else if (env -> symbol_table.Size() > 0)
  426.     {
  427.         old_type = env -> symbol_table.FindTypeSymbol(name_symbol); // check the whole stack !
  428.         if (old_type)
  429.         {
  430.             ReportSemError(SemanticError::DUPLICATE_LOCAL_TYPE_DECLARATION,
  431.                            identifier_token,
  432.                            identifier_token,
  433.                            name_symbol -> Name(),
  434.                            old_type -> FileLoc());
  435.         }
  436.     }
  437.     else if (env -> Type() -> Identity() == name_symbol)
  438.     {
  439.         ReportSemError(SemanticError::DUPLICATE_INNER_TYPE_NAME,
  440.                        identifier_token,
  441.                        identifier_token,
  442.                        name_symbol -> Name(),
  443.                        env -> Type() -> FileLoc());
  444.     }
  445.     else
  446.     {
  447.         //
  448.         // ... Then check the enclosing environments...
  449.         //
  450.         for (env = env -> previous; env; env = env -> previous)
  451.         {
  452.             TypeSymbol *old_type = (env -> symbol_table.Size() > 0
  453.                                          ? env -> symbol_table.FindTypeSymbol(name_symbol)
  454.                                          : (TypeSymbol *) NULL);
  455.             if (old_type)
  456.             {
  457.                 ReportSemError(SemanticError::DUPLICATE_LOCAL_TYPE_DECLARATION,
  458.                                identifier_token,
  459.                                identifier_token,
  460.                                name_symbol -> Name());
  461.                 break;
  462.             }
  463.             else if (env -> Type() -> Identity() == name_symbol)
  464.             {
  465.                 ReportSemError(SemanticError::DUPLICATE_INNER_TYPE_NAME,
  466.                                identifier_token,
  467.                                identifier_token,
  468.                                name_symbol -> Name(),
  469.                                env -> Type() -> FileLoc());
  470.                 break;
  471.             }
  472.         }
  473.     }
  474.  
  475.     return;
  476. }
  477.  
  478.  
  479. TypeSymbol *Semantic::ProcessNestedClassName(TypeSymbol *containing_type, AstClassDeclaration *class_declaration)
  480. {
  481.     CheckNestedTypeDuplication(containing_type -> semantic_environment, class_declaration -> identifier_token);
  482.  
  483.     NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(class_declaration -> identifier_token);
  484.     TypeSymbol *outermost_type = containing_type -> outermost_type;
  485.  
  486.     int length = containing_type -> ExternalNameLength() + 1 + name_symbol -> NameLength(); // +1 for $,... +1 for $
  487.     wchar_t *external_name = new wchar_t[length + 1]; // +1 for '\0';
  488.     wcscpy(external_name, containing_type -> ExternalName());
  489.     wcscat(external_name, StringConstant::US__DS_);
  490.     wcscat(external_name, name_symbol -> Name());
  491.  
  492.     TypeSymbol *inner_type = containing_type -> InsertNestedTypeSymbol(name_symbol);
  493.     inner_type -> outermost_type = outermost_type;
  494.     inner_type -> supertypes_closure = new SymbolSet;
  495.     inner_type -> subtypes = new SymbolSet;
  496.     inner_type -> SetExternalIdentity(control.FindOrInsertName(external_name, length));
  497.     inner_type -> semantic_environment = new SemanticEnvironment((Semantic *) this,
  498.                                                                  inner_type,
  499.                                                                  containing_type -> semantic_environment);
  500.     inner_type -> declaration = class_declaration;
  501.     inner_type -> file_symbol = source_file_symbol;
  502.     inner_type -> SetFlags(containing_type -> ACC_INTERFACE()
  503.                                             ? ProcessStaticNestedClassModifiers(class_declaration)
  504.                                             : ProcessNestedClassModifiers(class_declaration));
  505.     inner_type -> SetOwner(containing_type);
  506.     //
  507.     // Add 3 extra elements for padding. May need a default constructor and other support elements.
  508.     //
  509.     inner_type -> SetSymbolTable(class_declaration -> class_body -> NumClassBodyDeclarations() + 3);
  510.     inner_type -> SetLocation();
  511.     inner_type -> SetSignature(control);
  512.  
  513.     //
  514.     // If not a top-level type, then add pointer to enclosing type.
  515.     //
  516.     if (! inner_type -> ACC_STATIC())
  517.         inner_type -> InsertThis(0);
  518.  
  519.     if (inner_type -> IsLocal())
  520.     {
  521.         if (! outermost_type -> local)
  522.             outermost_type -> local = new SymbolSet;
  523.         outermost_type -> local -> AddElement(inner_type);
  524.     }
  525.     else
  526.     {
  527.         if (! outermost_type -> non_local)
  528.             outermost_type -> non_local = new SymbolSet;
  529.         outermost_type -> non_local -> AddElement(inner_type);
  530.     }
  531.  
  532.     class_declaration -> semantic_environment = inner_type -> semantic_environment; // save for processing bodies later.
  533.  
  534.     CheckClassMembers(inner_type, class_declaration -> class_body);
  535.  
  536.     delete [] external_name;
  537.  
  538.     return inner_type;
  539. }
  540.  
  541.  
  542. void Semantic::CheckInterfaceMembers(TypeSymbol *containing_type, AstInterfaceDeclaration *interface_declaration)
  543. {
  544.     for (int i = 0; i < interface_declaration -> NumNestedClasses(); i++)
  545.     {
  546.         AstClassDeclaration *class_declaration = interface_declaration -> NestedClass(i);
  547.  
  548.         if (! control.option.one_one)
  549.         {
  550.              ReportSemError(SemanticError::ONE_ONE_FEATURE,
  551.                             class_declaration -> LeftToken(),
  552.                             class_declaration -> RightToken());
  553.         }
  554.  
  555.         ProcessNestedClassName(containing_type, class_declaration);
  556.     }
  557.  
  558.     for (int j = 0; j < interface_declaration -> NumNestedInterfaces(); j++)
  559.     {
  560.         AstInterfaceDeclaration *inner_interface_declaration = interface_declaration -> NestedInterface(j);
  561.  
  562.         if (! control.option.one_one)
  563.         {
  564.             ReportSemError(SemanticError::ONE_ONE_FEATURE,
  565.                            inner_interface_declaration -> LeftToken(),
  566.                            inner_interface_declaration -> RightToken());
  567.         }
  568.  
  569.         ProcessNestedInterfaceName(containing_type, inner_interface_declaration);
  570.     }
  571.  
  572.     for (int l = 0; l < interface_declaration -> NumEmptyDeclarations(); l++)
  573.     {
  574.         if (control.option.pedantic)
  575.         {
  576.             ReportSemError(SemanticError::EMPTY_DECLARATION,
  577.                            interface_declaration -> EmptyDeclaration(l) -> LeftToken(),
  578.                            interface_declaration -> EmptyDeclaration(l) -> RightToken());
  579.         }
  580.     }
  581.  
  582.     return;
  583. }
  584.  
  585.  
  586. TypeSymbol *Semantic::ProcessNestedInterfaceName(TypeSymbol *containing_type, AstInterfaceDeclaration *interface_declaration)
  587. {
  588.     CheckNestedTypeDuplication(containing_type -> semantic_environment, interface_declaration -> identifier_token);
  589.  
  590.     NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(interface_declaration -> identifier_token);
  591.     TypeSymbol *outermost_type = containing_type -> outermost_type;
  592.  
  593.     int length = containing_type -> ExternalNameLength() + 1 + name_symbol -> NameLength(); // +1 for $,... +1 for $
  594.     wchar_t *external_name = new wchar_t[length + 1]; // +1 for '\0';
  595.     wcscpy(external_name, containing_type -> ExternalName());
  596.     wcscat(external_name, StringConstant::US__DS_);
  597.     wcscat(external_name, name_symbol -> Name());
  598.  
  599.     TypeSymbol *inner_type = containing_type -> InsertNestedTypeSymbol(name_symbol);
  600.     inner_type -> outermost_type = outermost_type;
  601.     inner_type -> supertypes_closure = new SymbolSet;
  602.     inner_type -> subtypes = new SymbolSet;
  603.     inner_type -> SetExternalIdentity(control.FindOrInsertName(external_name, length));
  604.     inner_type -> semantic_environment = new SemanticEnvironment((Semantic *) this,
  605.                                                                  inner_type,
  606.                                                                  containing_type -> semantic_environment);
  607.     inner_type -> declaration = interface_declaration;
  608.     inner_type -> file_symbol = source_file_symbol;
  609.     inner_type -> SetFlags(ProcessNestedInterfaceModifiers(interface_declaration));
  610.     inner_type -> SetOwner(containing_type);
  611.     inner_type -> SetSymbolTable(interface_declaration -> NumInterfaceMemberDeclarations());
  612.     inner_type -> SetLocation();
  613.     inner_type -> SetSignature(control);
  614.  
  615.     if (inner_type -> IsLocal())
  616.     {
  617.         if (! outermost_type -> local)
  618.             outermost_type -> local = new SymbolSet;
  619.         outermost_type -> local -> AddElement(inner_type);
  620.     }
  621.     else
  622.     {
  623.         if (! outermost_type -> non_local)
  624.             outermost_type -> non_local = new SymbolSet;
  625.         outermost_type -> non_local -> AddElement(inner_type);
  626.     }
  627.  
  628.     interface_declaration -> semantic_environment = inner_type -> semantic_environment; // save for processing bodies later.
  629.  
  630.     CheckInterfaceMembers(inner_type, interface_declaration);
  631.  
  632.     delete [] external_name;
  633.  
  634.     return inner_type;
  635. }
  636.  
  637.  
  638. //
  639. // Pass 1.2: Process all import statements
  640. //
  641. void Semantic::ProcessImports()
  642. {
  643.     for (int i = 0; i < compilation_unit -> NumImportDeclarations(); i++)
  644.     {
  645.         AstImportDeclaration *import_declaration = compilation_unit -> ImportDeclaration(i);
  646.  
  647.         if (import_declaration -> star_token_opt)
  648.              ProcessTypeImportOnDemandDeclaration(import_declaration);
  649.         else ProcessSingleTypeImportDeclaration(import_declaration);
  650.     }
  651.  
  652.     return;
  653. }
  654.  
  655.  
  656. //
  657. // Pass 1.3: Process outer types in "extends" and "implements" clauses associated with the types.
  658. //
  659. void Semantic::ProcessSuperTypes()
  660. {
  661.     //
  662.     // Process outer type of superclasses and interfaces and make sure that compilation unit
  663.     // contains exactly one public type.
  664.     //
  665.     TypeSymbol *public_type = NULL;
  666.     for (int i = 0; i < compilation_unit -> NumTypeDeclarations(); i++)
  667.     {
  668.         TypeSymbol *type = NULL;
  669.  
  670.         Ast *type_declaration = compilation_unit -> TypeDeclaration(i);
  671.         switch(type_declaration -> kind)
  672.         {
  673.             case Ast::CLASS:
  674.             {
  675.                 AstClassDeclaration *class_declaration = (AstClassDeclaration *) type_declaration;
  676.                 if (class_declaration -> semantic_environment)
  677.                 {
  678.                     type = class_declaration -> semantic_environment -> Type();
  679.                     if (class_declaration -> super_opt)
  680.                     {
  681.                         TypeSymbol *super_type = FindFirstType(class_declaration -> super_opt) -> symbol -> TypeCast();
  682.                         if (super_type)
  683.                             super_type -> subtypes -> AddElement(type);
  684.                     }
  685.  
  686.                     for (int k = 0; k < class_declaration -> NumInterfaces(); k++)
  687.                     {
  688.                         TypeSymbol *super_type = FindFirstType(class_declaration -> Interface(k)) -> symbol -> TypeCast();
  689.                         if (super_type)
  690. {
  691. assert(super_type -> subtypes);
  692.                             super_type -> subtypes -> AddElement(type);
  693. }
  694.                     }
  695.  
  696.                     ProcessOuterType(class_declaration);
  697.                 }
  698.                 break;
  699.             }
  700.             case Ast::INTERFACE:
  701.             {
  702.                 AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) type_declaration;
  703.                 if (interface_declaration -> semantic_environment)
  704.                 {
  705.                     type = interface_declaration -> semantic_environment -> Type();
  706.                     for (int k = 0; k < interface_declaration -> NumExtendsInterfaces(); k++)
  707.                     {
  708.                         TypeSymbol *super_type = FindFirstType(interface_declaration -> ExtendsInterface(k)) -> symbol -> TypeCast();
  709.                         if (super_type)
  710.                             super_type -> subtypes -> AddElement(type);
  711.                     }
  712.  
  713.                     ProcessOuterType(interface_declaration);
  714.                 }
  715.                 break;
  716.             }
  717.             default:
  718.                 break;
  719.         }
  720.  
  721.         if (type && type -> ACC_PUBLIC())
  722.         {
  723.             if (! public_type)
  724.             {
  725.                 public_type = type;
  726.  
  727.                 if  (source_file_symbol -> Identity() != public_type -> Identity())
  728.                 {
  729.                     if (type -> ACC_INTERFACE())
  730.                     {
  731.                         AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) type_declaration;
  732.                         ReportSemError(SemanticError::MISMATCHED_TYPE_AND_FILE_NAMES,
  733.                                        interface_declaration -> identifier_token,
  734.                                        interface_declaration -> identifier_token,
  735.                                        public_type -> Name());
  736.                     }
  737.                     else
  738.                     {
  739.                         AstClassDeclaration *class_declaration = (AstClassDeclaration *) type_declaration;
  740.                         ReportSemError(SemanticError::MISMATCHED_TYPE_AND_FILE_NAMES,
  741.                                        class_declaration -> identifier_token,
  742.                                        class_declaration -> identifier_token,
  743.                                        public_type -> Name());
  744.                     }
  745.                 }
  746.             }
  747.             else
  748.             {
  749.                 if (type -> ACC_INTERFACE())
  750.                 {
  751.                     AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) type_declaration;
  752.                     ReportSemError(SemanticError::MULTIPLE_PUBLIC_TYPES,
  753.                                    interface_declaration -> identifier_token,
  754.                                    interface_declaration -> identifier_token,
  755.                                    type -> Name(),
  756.                                    public_type -> Name());
  757.                 }
  758.                 else
  759.                 {
  760.                     AstClassDeclaration *class_declaration = (AstClassDeclaration *) type_declaration;
  761.                     ReportSemError(SemanticError::MULTIPLE_PUBLIC_TYPES,
  762.                                    class_declaration -> identifier_token,
  763.                                    class_declaration -> identifier_token,
  764.                                    type -> Name(),
  765.                                    public_type -> Name());
  766.                 }
  767.             }
  768.         }
  769.     }
  770.  
  771.     return;
  772. }
  773.  
  774.  
  775. void Semantic::ProcessOuterType(AstClassDeclaration *class_declaration)
  776. {
  777.     TypeSymbol *type = class_declaration -> semantic_environment -> Type();
  778.  
  779.     //
  780.     // If a type has no super type, set it up properly in case
  781.     // it is expanded prematurely by one of its dependents.
  782.     //
  783.     if (! class_declaration -> super_opt && class_declaration -> NumInterfaces() == 0)
  784.     {
  785.         if (type -> Identity() != control.object_name_symbol ||
  786.             type -> ContainingPackage() != control.system_package || type -> IsNested())
  787.             type -> super = control.Object();
  788.     }
  789.  
  790.     AstClassBody *class_body = class_declaration -> class_body;
  791.     for (int i = 0; i < class_body -> NumNestedClasses(); i++)
  792.     {
  793.         AstClassDeclaration *inner_class_declaration = class_body -> NestedClass(i);
  794.         if (inner_class_declaration -> semantic_environment)
  795.             ProcessOuterType(inner_class_declaration);
  796.     }
  797.  
  798.     for (int j = 0; j < class_body -> NumNestedInterfaces(); j++)
  799.     {
  800.         AstInterfaceDeclaration *inner_interface_declaration = class_body -> NestedInterface(j);
  801.         if (inner_interface_declaration -> semantic_environment)
  802.             ProcessOuterType(inner_interface_declaration);
  803.     }
  804.  
  805.     return;
  806. }
  807.  
  808.  
  809. void Semantic::ProcessOuterType(AstInterfaceDeclaration *interface_declaration)
  810. {
  811.     TypeSymbol *type = interface_declaration -> semantic_environment -> Type();
  812.  
  813.     //
  814.     // Set it up an interface properly in case it is 
  815.     // expanded prematurely by one of its dependents.
  816.     //
  817.     type -> super = control.Object();
  818.  
  819.     for (int i = 0; i < interface_declaration -> NumNestedClasses(); i++)
  820.     {
  821.         AstClassDeclaration *inner_class_declaration = interface_declaration -> NestedClass(i);
  822.         if (inner_class_declaration -> semantic_environment)
  823.             ProcessOuterType(inner_class_declaration);
  824.     }
  825.  
  826.     for (int j = 0; j < interface_declaration -> NumNestedInterfaces(); j++)
  827.     {
  828.         AstInterfaceDeclaration *inner_interface_declaration = interface_declaration -> NestedInterface(j);
  829.         if (inner_interface_declaration -> semantic_environment)
  830.             ProcessOuterType(inner_interface_declaration);
  831.     }
  832.  
  833.     return;
  834. }
  835.  
  836.  
  837. //
  838. // Pass 2: Process "extends" and "implements" clauses associated with the types.
  839. //
  840. void Semantic::ProcessTypeHeader(AstClassDeclaration *class_declaration)
  841. {
  842.     state_stack.Push(class_declaration -> semantic_environment);
  843.     TypeSymbol *this_type = ThisType();
  844. assert(! this_type -> HeaderProcessed() || this_type -> Bad());
  845.  
  846.     if (! class_declaration -> super_opt)
  847.     {
  848.         if (this_type -> Identity() != control.object_name_symbol ||
  849.             this_package != control.system_package || this_type -> IsNested())
  850.             SetObjectSuperType(this_type, class_declaration -> identifier_token);
  851.     }
  852.     else
  853.     {
  854.         TypeSymbol *super_type = MustFindType(class_declaration -> super_opt);
  855.  
  856. assert(this_type -> subtypes_closure);
  857. assert(! super_type -> SourcePending());
  858.  
  859.         this_type -> super = super_type;
  860.  
  861.         if (this_type -> subtypes_closure -> IsElement(super_type)) // if there is a cycle, break it and issue an error message
  862.         {
  863.             this_type -> super = control.Object();
  864.             this_type -> MarkCircular();
  865.             ReportSemError(SemanticError::CIRCULAR_CLASS,
  866.                            class_declaration -> identifier_token,
  867.                            class_declaration -> super_opt -> RightToken(),
  868.                            this_type -> ContainingPackage() -> PackageName(),
  869.                            this_type -> ExternalName());
  870.         }
  871.         else if (this_type -> Identity() == control.object_name_symbol &&
  872.                  this_package == control.system_package && (! this_type -> IsNested()))
  873.         {
  874.              ReportSemError(SemanticError::OBJECT_WITH_SUPER_TYPE,
  875.                             class_declaration -> super_opt -> LeftToken(),
  876.                             class_declaration -> super_opt -> RightToken(),
  877.                             this_type -> ContainingPackage() -> PackageName(),
  878.                             this_type -> ExternalName());
  879.              this_type -> super = NULL;
  880.         }
  881.         else if (this_type -> super -> ACC_INTERFACE())
  882.         {
  883.             ReportSemError(SemanticError::NOT_A_CLASS,
  884.                            class_declaration -> super_opt -> LeftToken(),
  885.                            class_declaration -> super_opt -> RightToken(),
  886.                            this_type -> super -> ContainingPackage() -> PackageName(),
  887.                            this_type -> super -> ExternalName());
  888.  
  889.             SetObjectSuperType(this_type, class_declaration -> identifier_token);
  890.         }
  891.         else if (this_type -> super -> ACC_FINAL())
  892.         {
  893.              ReportSemError(SemanticError::SUPER_IS_FINAL,
  894.                             class_declaration -> super_opt -> LeftToken(),
  895.                             class_declaration -> super_opt -> RightToken(),
  896.                             this_type -> super -> ContainingPackage() -> PackageName(),
  897.                             this_type -> super -> ExternalName());
  898.         }
  899.     }
  900.  
  901.     for (int i = 0; i < class_declaration -> NumInterfaces(); i++)
  902.         ProcessInterface(class_declaration -> Interface(i));
  903.  
  904.     this_type -> MarkHeaderProcessed();
  905.  
  906.     state_stack.Pop();
  907.  
  908.     return;
  909. }
  910.  
  911.  
  912. void Semantic::ProcessTypeHeader(AstInterfaceDeclaration *interface_declaration)
  913. {
  914.     state_stack.Push(interface_declaration -> semantic_environment);
  915.     TypeSymbol *this_type = ThisType();
  916. assert(! this_type -> HeaderProcessed() || this_type -> Bad());
  917.  
  918.     SetObjectSuperType(this_type, interface_declaration -> identifier_token);
  919.     for (int k = 0; k < interface_declaration -> NumExtendsInterfaces(); k++)
  920.         ProcessInterface(interface_declaration -> ExtendsInterface(k));
  921. assert(this_type -> subtypes_closure);
  922.     for (int i = 0; i < this_type -> NumInterfaces(); i++)
  923.     {
  924.         if (this_type -> subtypes_closure -> IsElement(this_type -> Interface(i)))
  925.         {
  926.             this_type -> ResetInterfaces(); // Remove all the interfaces if a loop is detected. The error will be reported later
  927.             this_type -> MarkCircular();
  928.             ReportSemError(SemanticError::CIRCULAR_INTERFACE,
  929.                            interface_declaration -> identifier_token,
  930.                            interface_declaration -> ExtendsInterface(interface_declaration -> NumExtendsInterfaces() - 1) -> RightToken(),
  931.                            this_type -> ContainingPackage() -> PackageName(),
  932.                            this_type -> ExternalName());
  933.             break;
  934.         }
  935.     }
  936.  
  937.     this_type -> MarkHeaderProcessed();
  938.  
  939.     state_stack.Pop();
  940.  
  941.     return;
  942. }
  943.  
  944.  
  945. //
  946. // Marked type and all other types that are nested inside it "circular"
  947. //
  948. void Semantic::MarkCircularNest(TypeSymbol *type)
  949. {
  950.     if (type -> Circular())
  951.         return;
  952.  
  953.     //
  954.     // Mark the type as circular
  955.     //
  956.     type -> MarkCircular();
  957.     type -> super = control.Object();
  958.     type -> ResetInterfaces();
  959.  
  960.     //
  961.     // Recursively, process any nested type...
  962.     //
  963.     AstClassDeclaration *class_declaration = type -> declaration -> ClassDeclarationCast();
  964.     if (class_declaration)
  965.     {
  966.         AstClassBody *class_body = class_declaration -> class_body;
  967.         for (int i = 0; i < class_body -> NumNestedClasses(); i++)
  968.             MarkCircularNest(class_body -> NestedClass(i) -> semantic_environment -> Type());
  969.         for (int k = 0; k < class_body -> NumNestedInterfaces(); k++)
  970.             MarkCircularNest(class_body -> NestedInterface(k) -> semantic_environment -> Type());
  971.     }
  972.     else
  973.     {
  974.         AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) type -> declaration;
  975.         for (int i = 0; i < interface_declaration -> NumNestedClasses(); i++)
  976.             MarkCircularNest(interface_declaration -> NestedClass(i) -> semantic_environment -> Type());
  977.         for (int k = 0; k < interface_declaration -> NumNestedInterfaces(); k++)
  978.             MarkCircularNest(interface_declaration -> NestedInterface(k) -> semantic_environment -> Type());
  979.     }
  980.  
  981.     return;
  982. }
  983.  
  984.  
  985. //
  986. // Compute the set of super types associated with this outer-level type
  987. // and check for circularity.
  988. //
  989. void Semantic::ProcessSuperTypesOfOuterType(TypeSymbol *type)
  990. {
  991. assert((! type -> IsNested()) || type -> owner -> MethodCast());
  992.     if (type -> super)
  993.     {
  994.         type -> supertypes_closure -> AddElement(type -> super -> outermost_type);
  995.         type -> supertypes_closure -> Union(*type -> super -> outermost_type -> supertypes_closure);
  996.     }
  997.  
  998.     for (int k = 0; k < type -> NumInterfaces(); k++)
  999.     {
  1000.         type -> supertypes_closure -> AddElement(type -> Interface(k) -> outermost_type);
  1001.         type -> supertypes_closure -> Union(*type -> Interface(k) -> outermost_type -> supertypes_closure);
  1002.     }
  1003.  
  1004.     SymbolSet &inner_types = *(type -> innertypes_closure);
  1005.     for (TypeSymbol *inner_type = (TypeSymbol *) inner_types.FirstElement();
  1006.                      inner_type;
  1007.                      inner_type = (TypeSymbol *) inner_types.NextElement())
  1008.     {
  1009.         TypeSymbol *super_type = inner_type -> super;
  1010.         for (int k = 0; super_type;
  1011.                         super_type = (TypeSymbol *) (k < inner_type -> NumInterfaces() ? inner_type -> Interface(k++) : NULL))
  1012.         {
  1013.             if (super_type -> outermost_type != type)
  1014.             {
  1015.                 type -> supertypes_closure -> AddElement(super_type -> outermost_type);
  1016.                 type -> supertypes_closure -> Union(*super_type -> outermost_type -> supertypes_closure);
  1017.             }
  1018.         }
  1019.     }
  1020.  
  1021.     bool circular = type -> supertypes_closure -> IsElement(type) ||
  1022.                     type -> subtypes_closure -> Intersects(*type -> supertypes_closure);
  1023.     if (circular)
  1024.     {
  1025.         if (type -> Circular())        // If the type is already marked circular, an error message has already been issued
  1026.             type -> MarkNonCircular(); // Remove the circular mark, so that we can remark the whole "nest" ?
  1027.         else
  1028.         {
  1029.             if (type -> ACC_INTERFACE())
  1030.             {
  1031.                 AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) type -> declaration;
  1032.                 int right_token_index = interface_declaration -> NumExtendsInterfaces() - 1;
  1033.  
  1034.                 ReportSemError(SemanticError::CIRCULAR_INTERFACE,
  1035.                                interface_declaration -> identifier_token,
  1036.                                (interface_declaration -> NumExtendsInterfaces() > 0
  1037.                                                        ? interface_declaration -> ExtendsInterface(right_token_index) -> RightToken()
  1038.                                                        : interface_declaration -> identifier_token),
  1039.                                type -> ContainingPackage() -> PackageName(),
  1040.                                type -> ExternalName());
  1041.             }
  1042.             else
  1043.             {
  1044.                 AstClassDeclaration *class_declaration = (AstClassDeclaration *) type -> declaration;
  1045.                 int right_token_index = class_declaration -> NumInterfaces() - 1;
  1046.  
  1047.                 ReportSemError(SemanticError::CIRCULAR_CLASS,
  1048.                                class_declaration -> identifier_token,
  1049.                                (class_declaration -> NumInterfaces() > 0
  1050.                                                    ? class_declaration -> Interface(right_token_index) -> RightToken()
  1051.                                                    : (class_declaration -> super_opt
  1052.                                                                          ? class_declaration -> super_opt -> RightToken()
  1053.                                                                          : class_declaration -> identifier_token)),
  1054.                                type -> ContainingPackage() -> PackageName(),
  1055.                                type -> ExternalName());
  1056.  
  1057.                 SetObjectSuperType(type, class_declaration -> identifier_token);
  1058. assert(type -> Identity() != control.object_name_symbol || type -> ContainingPackage() != control.system_package);
  1059.             }
  1060.         }
  1061.  
  1062.         MarkCircularNest(type);
  1063.     }
  1064.  
  1065.     return;
  1066. }
  1067.  
  1068.  
  1069. //
  1070. // The array partially_ordered_types contains a list of inner types. For
  1071. // each of these types, compute the set of super types associated with it
  1072. // and check for circularity.
  1073. //
  1074. void Semantic::ProcessSuperTypesOfInnerType(TypeSymbol *type, Tuple<TypeSymbol *> &partially_ordered_types)
  1075. {
  1076.     for (int l = 0; l < partially_ordered_types.Length(); l++)
  1077.     {
  1078.         TypeSymbol *inner_type = partially_ordered_types[l];
  1079.  
  1080.         SymbolSet &nested_types = *(inner_type -> innertypes_closure);
  1081.         nested_types.AddElement(inner_type); // Compute reflexive transitive closure
  1082.         for (TypeSymbol *nested_type = (TypeSymbol *) nested_types.FirstElement();
  1083.                          nested_type;
  1084.                          nested_type = (TypeSymbol *) nested_types.NextElement())
  1085.         {
  1086.             TypeSymbol *super_type = nested_type -> super;
  1087.             for (int k = 0; super_type;
  1088.                             super_type = (TypeSymbol *) (k < nested_type -> NumInterfaces() ? nested_type -> Interface(k++) : NULL))
  1089.             {
  1090.                 for ( ; super_type; super_type = super_type -> owner -> TypeCast())
  1091.                 {
  1092.                     if (type -> innertypes_closure -> IsElement(super_type))
  1093.                         break;
  1094.                 }
  1095.  
  1096.                 if (super_type && super_type != inner_type)
  1097.                 {
  1098.                     inner_type -> supertypes_closure -> AddElement(super_type);
  1099.                     inner_type -> supertypes_closure -> Union(*super_type -> supertypes_closure);
  1100.                 }
  1101.             }
  1102.         }
  1103.  
  1104.         bool circular = inner_type -> supertypes_closure -> IsElement(inner_type) ||
  1105.                         inner_type -> subtypes_closure -> Intersects(*inner_type -> supertypes_closure);
  1106.  
  1107.         if (circular)
  1108.         {
  1109.             MarkCircularNest(inner_type);
  1110.  
  1111.             if (inner_type -> ACC_INTERFACE())
  1112.             {
  1113.                 AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) inner_type -> declaration;
  1114.                 ReportSemError(SemanticError::CIRCULAR_INTERFACE,
  1115.                                interface_declaration -> identifier_token,
  1116.                                (interface_declaration -> NumExtendsInterfaces() > 0
  1117.                                                        ? interface_declaration -> ExtendsInterface(interface_declaration -> NumExtendsInterfaces() - 1) -> RightToken()
  1118.                                                        : interface_declaration -> identifier_token),
  1119.                                inner_type -> ContainingPackage() -> PackageName(),
  1120.                                inner_type -> ExternalName());
  1121.             }
  1122.             else
  1123.             {
  1124.                 AstClassDeclaration *class_declaration = (AstClassDeclaration *) inner_type -> declaration;
  1125.                 ReportSemError(SemanticError::CIRCULAR_CLASS,
  1126.                                class_declaration -> identifier_token,
  1127.                                (class_declaration -> NumInterfaces() > 0
  1128.                                                    ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  1129.                                                    : (class_declaration -> super_opt
  1130.                                                                          ? class_declaration -> super_opt -> RightToken()
  1131.                                                                          : class_declaration -> identifier_token)),
  1132.                                inner_type -> ContainingPackage() -> PackageName(),
  1133.                                inner_type -> ExternalName());
  1134.             }
  1135.         }
  1136.     }
  1137.  
  1138.     //
  1139.     // At this point the innertypes_closure set contains only the
  1140.     // immediate inner types.
  1141.     //
  1142.     if (partially_ordered_types.Length() > 1) // inner_types set has more than one element?
  1143.     {
  1144.         SymbolSet &inner_types = *(type -> innertypes_closure);
  1145. assert(partially_ordered_types.Length() == inner_types.Size());
  1146.         TopologicalSort *topological_sorter = new TopologicalSort(inner_types, partially_ordered_types);
  1147.         topological_sorter -> Sort();
  1148.         delete topological_sorter;
  1149.     }
  1150.  
  1151.     //
  1152.     // Now, complete the closure set of inner types.
  1153.     //
  1154.     for (int i = 0; i < partially_ordered_types.Length(); i++)
  1155.     {
  1156.         TypeSymbol *inner_type = partially_ordered_types[i];
  1157.         type -> AddNestedType(inner_type);
  1158.         type -> innertypes_closure -> Union(*(inner_type -> innertypes_closure));
  1159.     }
  1160.  
  1161.     return;
  1162. }
  1163.  
  1164.  
  1165. void Semantic::ProcessTypeHeaders(AstClassDeclaration *class_declaration)
  1166. {
  1167.     ProcessTypeHeader(class_declaration);
  1168.     ProcessNestedTypeHeaders(class_declaration -> semantic_environment -> Type(), class_declaration -> class_body);
  1169.     ProcessSuperTypesOfOuterType(class_declaration -> semantic_environment -> Type());
  1170.  
  1171.     return;
  1172. }
  1173.  
  1174.  
  1175. void Semantic::ProcessTypeHeaders(AstInterfaceDeclaration *interface_declaration)
  1176. {
  1177.     ProcessTypeHeader(interface_declaration);
  1178.     ProcessNestedTypeHeaders(interface_declaration);
  1179.     ProcessSuperTypesOfOuterType(interface_declaration -> semantic_environment -> Type());
  1180.  
  1181.     return;
  1182. }
  1183.  
  1184.  
  1185. void Semantic::ReportTypeInaccessible(LexStream::TokenIndex left_tok, LexStream::TokenIndex right_tok, TypeSymbol *type)
  1186. {
  1187.     ReportSemError(SemanticError::TYPE_NOT_ACCESSIBLE,
  1188.                    left_tok,
  1189.                    right_tok,
  1190.                    type -> ContainingPackage() -> PackageName(),
  1191.                    type -> ExternalName(),
  1192.                    (type -> ACC_PRIVATE() ? StringConstant::US_private : (type -> ACC_PROTECTED() ? StringConstant::US_protected : StringConstant::US_default)));
  1193.  
  1194.     return;
  1195. }
  1196.  
  1197.  
  1198. TypeSymbol *Semantic::FindNestedType(TypeSymbol *type, LexStream::TokenIndex identifier_token)
  1199. {
  1200.     if (type == control.null_type || type == control.no_type || type -> Primitive())
  1201.         return NULL;
  1202.  
  1203.     NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  1204.  
  1205.     if (! type -> expanded_type_table)
  1206.         ComputeTypesClosure(type, identifier_token);
  1207.     TypeShadowSymbol *type_shadow_symbol = type -> expanded_type_table -> FindTypeShadowSymbol(name_symbol);
  1208.  
  1209.     return (type_shadow_symbol ? FindTypeInShadow(type_shadow_symbol, identifier_token)
  1210.                                : type -> FindTypeSymbol(name_symbol));
  1211. }
  1212.  
  1213.  
  1214. TypeSymbol *Semantic::MustFindNestedType(TypeSymbol *type, Ast *name)
  1215. {
  1216.     AstSimpleName *simple_name = name -> SimpleNameCast();
  1217.     LexStream::TokenIndex identifier_token = (simple_name ? simple_name -> identifier_token
  1218.                                                           : ((AstFieldAccess *) name) -> identifier_token);
  1219.  
  1220.     TypeSymbol *inner_type = FindNestedType(type, identifier_token);
  1221.     if (inner_type)
  1222.          TypeAccessCheck(name, inner_type);
  1223.     else inner_type = GetBadNestedType(type, identifier_token);
  1224.  
  1225.     return inner_type;
  1226. }
  1227.  
  1228.  
  1229. //
  1230. // The Ast name is a qualified name (simple name or a field access). The function FindTypeInLayer
  1231. // searches for the first subname that is the name of a type contained in the set inner_types.
  1232. // If such a type is found, it is returned. Otherwise, the whole qualified name is resolved to
  1233. // a symbol that is returned. 
  1234. //
  1235. TypeSymbol *Semantic::FindTypeInLayer(Ast *name, SymbolSet &inner_types)
  1236. {
  1237.     //
  1238.     // Unwind all the field accesses until we get to a base that is a simple name
  1239.     //
  1240.     Tuple<AstFieldAccess *> field;
  1241.     for (AstFieldAccess *field_access = name -> FieldAccessCast(); field_access; field_access = field_access -> base -> FieldAccessCast())
  1242.     {
  1243.         field.Next() = field_access;
  1244.         name = field_access -> base;
  1245.     }
  1246.  
  1247.     //
  1248.     // If the simple_name base is a type that is an element in the inner_types set
  1249.     // return it. Otherwise, assume it is a package name...
  1250.     //
  1251.     AstSimpleName *simple_name = name -> SimpleNameCast();
  1252. assert(simple_name);
  1253.     PackageSymbol *package = NULL;
  1254.     TypeSymbol *type = FindType(simple_name -> identifier_token);
  1255.     if (type)
  1256.     {
  1257.         if (inner_types.IsElement(type))
  1258.             return type;
  1259.     }
  1260.     else // If the simple_name is not a type, assume it is a package
  1261.     {
  1262.         NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(simple_name -> identifier_token);
  1263.         package = control.external_table.FindPackageSymbol(name_symbol);
  1264.         if (! package)
  1265.             package = control.external_table.InsertPackageSymbol(name_symbol, NULL);
  1266.         control.FindPathsToDirectory(package);
  1267.     }
  1268.  
  1269.     //
  1270.     // We now go through the field access in order until we either encouter a type that is an element of inner_types,
  1271.     // in which case, we return the type. Otherwise, we return NULL.
  1272.     //
  1273.     //
  1274.     for (int i = field.Length() - 1; i >= 0; i--)
  1275.     {
  1276.         AstFieldAccess *field_access = field[i];
  1277.  
  1278.         if (type) // The base name is a type that is not contained in the inner_types set?
  1279.         {
  1280.             type = FindNestedType(type, field_access -> identifier_token); // resolve the next type...
  1281.             if (! type)
  1282.                 break;
  1283.             if (inner_types.IsElement(type))
  1284.                 return type;
  1285.         }
  1286.         else 
  1287.         {
  1288.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(field_access -> identifier_token);
  1289.             type = package -> FindTypeSymbol(name_symbol);
  1290.             if (! type)
  1291.             {
  1292.                 FileSymbol *file_symbol = Control::GetFile(package, name_symbol, control.option.depend);
  1293.                 if (file_symbol)
  1294.                     type = ReadType(file_symbol, package, name_symbol, field_access -> identifier_token);
  1295.             }
  1296.             else if (type -> SourcePending())
  1297.                  control.ProcessHeaders(type -> file_symbol);
  1298.  
  1299.             //            
  1300.             //            
  1301.             //
  1302.             if (type)
  1303.             {
  1304.                 if (inner_types.IsElement(type))
  1305.                     return type;
  1306.             }
  1307.             else // If the field access was not resolved to a type assume it is a package
  1308.             {
  1309.                 NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(field_access -> identifier_token);
  1310.                 PackageSymbol *subpackage = package -> FindPackageSymbol(name_symbol);
  1311.                 if (! subpackage)
  1312.                     subpackage = package -> InsertPackageSymbol(name_symbol);
  1313.                 control.FindPathsToDirectory(subpackage);
  1314.                 package = subpackage;
  1315.             }
  1316.         }
  1317.     }
  1318.  
  1319.     return NULL;
  1320. }
  1321.  
  1322.  
  1323. void Semantic::ProcessNestedSuperTypes(TypeSymbol *type)
  1324. {
  1325.     int num_inner_types = type -> innertypes_closure -> Size();
  1326.  
  1327.     if (num_inner_types > 0)
  1328.     {
  1329.         SymbolSet &inner_types = *(type -> innertypes_closure);
  1330.  
  1331.         for (TypeSymbol *inner_type = (TypeSymbol *) inner_types.FirstElement();
  1332.                          inner_type;
  1333.                          inner_type = (TypeSymbol *) inner_types.NextElement())
  1334.         {
  1335.             if (inner_type -> ACC_INTERFACE())
  1336.             {
  1337.                 AstInterfaceDeclaration *inner_interface_declaration = (AstInterfaceDeclaration *) inner_type -> declaration;
  1338.  
  1339.                 for (int l = 0; l < inner_interface_declaration -> NumExtendsInterfaces(); l++)
  1340.                 {
  1341.                     AstExpression *interface_name = inner_interface_declaration -> ExtendsInterface(l);
  1342.                     TypeSymbol *super_type = FindTypeInLayer(interface_name, inner_types);
  1343.                     if (super_type)
  1344.                         super_type -> subtypes -> AddElement(inner_type);
  1345.                 }
  1346.             }
  1347.             else
  1348.             {
  1349.                 AstClassDeclaration *inner_class_declaration = (AstClassDeclaration *) inner_type -> declaration;
  1350.  
  1351.                 if (inner_class_declaration -> super_opt)
  1352.                 {
  1353.                     TypeSymbol *super_type = FindTypeInLayer(inner_class_declaration -> super_opt, inner_types);
  1354.                     if (super_type)
  1355.                         super_type -> subtypes -> AddElement(inner_type);
  1356.                 }
  1357.  
  1358.                 for (int l = 0; l < inner_class_declaration -> NumInterfaces(); l++)
  1359.                 {
  1360.                     TypeSymbol *super_type = FindTypeInLayer(inner_class_declaration -> Interface(l), inner_types);
  1361.                     if (super_type)
  1362.                         super_type -> subtypes -> AddElement(inner_type);
  1363.                 }
  1364.             }
  1365.         }
  1366.  
  1367.         //
  1368.         // Create a partial order or the inner types. If there are cycles,
  1369.         // then the order is arbitrary.
  1370.         //
  1371.         Tuple<TypeSymbol *> partially_ordered_types;
  1372.  
  1373.         if (num_inner_types > 0) // inner_types set is not empty?
  1374.         {
  1375.             TypeCycleChecker *cycle_checker = new TypeCycleChecker(partially_ordered_types);
  1376.             cycle_checker -> PartialOrder(inner_types);
  1377.             delete cycle_checker;
  1378.         }
  1379.  
  1380.         for (int k = 0; k < partially_ordered_types.Length(); k++)
  1381.         {
  1382.             TypeSymbol *inner_type = partially_ordered_types[k];
  1383.             if (inner_type -> ACC_INTERFACE())
  1384.             {
  1385.                 AstInterfaceDeclaration *inner_interface_declaration = (AstInterfaceDeclaration *) inner_type -> declaration;
  1386.                 ProcessTypeHeader(inner_interface_declaration);
  1387.                 ProcessNestedTypeHeaders(inner_interface_declaration);
  1388.             }
  1389.             else
  1390.             {
  1391.                 AstClassDeclaration *inner_class_declaration = (AstClassDeclaration *) inner_type -> declaration;
  1392.                 ProcessTypeHeader(inner_class_declaration);
  1393.                 ProcessNestedTypeHeaders(inner_class_declaration -> semantic_environment -> Type(),
  1394.                                         inner_class_declaration -> class_body);
  1395.             }
  1396.         }
  1397.  
  1398.         ProcessSuperTypesOfInnerType(type, partially_ordered_types);
  1399.     }
  1400.  
  1401.     return;
  1402. }
  1403.  
  1404.  
  1405. void Semantic::ProcessNestedTypeHeaders(TypeSymbol *type, AstClassBody *class_body)
  1406. {
  1407.     if (type -> expanded_type_table && (type -> super != control.Object() || type -> NumInterfaces() > 0))
  1408.     {
  1409.         delete type -> expanded_type_table;
  1410.         type  -> expanded_type_table = NULL;
  1411.     }
  1412.  
  1413.     if (! type -> expanded_type_table)
  1414.         ComputeTypesClosure(type, class_body -> left_brace_token);
  1415.  
  1416.     state_stack.Push(type -> semantic_environment);
  1417.  
  1418.     type -> innertypes_closure = new SymbolSet;
  1419.  
  1420.     for (int i = 0; i < class_body -> NumNestedClasses(); i++)
  1421.     {
  1422.         if (class_body -> NestedClass(i) -> semantic_environment)
  1423.             type -> innertypes_closure -> AddElement(class_body -> NestedClass(i) -> semantic_environment -> Type());
  1424.     }
  1425.  
  1426.     for (int j = 0; j < class_body -> NumNestedInterfaces(); j++)
  1427.     {
  1428.         if (class_body -> NestedInterface(j) -> semantic_environment)
  1429.             type -> innertypes_closure -> AddElement(class_body -> NestedInterface(j) -> semantic_environment -> Type());
  1430.     }
  1431.  
  1432.     ProcessNestedSuperTypes(type);
  1433.  
  1434.     state_stack.Pop();
  1435.  
  1436.     return;
  1437. }
  1438.  
  1439.  
  1440. void Semantic::ProcessNestedTypeHeaders(AstInterfaceDeclaration *interface_declaration)
  1441. {
  1442.     TypeSymbol *type = interface_declaration -> semantic_environment -> Type();
  1443.     if (type -> expanded_type_table && type -> NumInterfaces() > 0)
  1444.     {
  1445.         delete type -> expanded_type_table;
  1446.         type  -> expanded_type_table = NULL;
  1447.     }
  1448.  
  1449.     if (! type -> expanded_type_table)
  1450.         ComputeTypesClosure(type, interface_declaration -> identifier_token);
  1451.  
  1452.     state_stack.Push(interface_declaration -> semantic_environment);
  1453.  
  1454.     type -> innertypes_closure = new SymbolSet;
  1455.  
  1456.     for (int i = 0; i < interface_declaration -> NumNestedClasses(); i++)
  1457.     {
  1458.         if (interface_declaration -> NestedClass(i) -> semantic_environment)
  1459.             type -> innertypes_closure -> AddElement(interface_declaration -> NestedClass(i) -> semantic_environment -> Type());
  1460.     }
  1461.  
  1462.     for (int j = 0; j < interface_declaration -> NumNestedInterfaces(); j++)
  1463.     {
  1464.         if (interface_declaration -> NestedInterface(j) -> semantic_environment)
  1465.             type -> innertypes_closure -> AddElement(interface_declaration -> NestedInterface(j) -> semantic_environment -> Type());
  1466.     }
  1467.  
  1468.     ProcessNestedSuperTypes(type);
  1469.  
  1470.     state_stack.Pop();
  1471.  
  1472.     return;
  1473. }
  1474.  
  1475.  
  1476. //
  1477. // Pass 3: Process all method and constructor declarations within the compilation unit so that
  1478. //         any field initialization enclosed in the compilation unit can invoke any constructor or
  1479. //         method within the unit.
  1480. //
  1481. inline void Semantic::ProcessConstructorMembers(AstClassBody *class_body)
  1482. {
  1483.     TypeSymbol *this_type = ThisType();
  1484. assert(this_type -> HeaderProcessed());
  1485.  
  1486.     //
  1487.     // If the class contains no constructor, ...
  1488.     //
  1489.     if (class_body -> NumConstructors() > 0)
  1490.     {
  1491.         for (int k = 0; k < class_body -> NumConstructors(); k++)
  1492.             ProcessConstructorDeclaration(class_body -> Constructor(k));
  1493.     }
  1494.     else if (! this_type -> Anonymous())
  1495.          AddDefaultConstructor(this_type);
  1496.  
  1497.     this_type -> MarkConstructorMembersProcessed();
  1498.  
  1499.     return;
  1500. }
  1501.  
  1502.  
  1503. inline void Semantic::ProcessMethodMembers(AstClassBody *class_body)
  1504. {
  1505. assert(ThisType() -> HeaderProcessed());
  1506.     for (int k = 0; k < class_body -> NumMethods(); k++)
  1507.         ProcessMethodDeclaration(class_body -> Method(k));
  1508.  
  1509.     ThisType() -> MarkMethodMembersProcessed();
  1510.  
  1511.     return;
  1512. }
  1513.  
  1514.  
  1515. inline void Semantic::ProcessFieldMembers(AstClassBody *class_body)
  1516. {
  1517. assert(ThisType() -> HeaderProcessed());
  1518.  
  1519.     for (int i = 0; i < class_body -> NumInstanceVariables(); i++)
  1520.         ProcessFieldDeclaration(class_body -> InstanceVariable(i));
  1521.  
  1522.     for (int k = 0; k < class_body -> NumClassVariables(); k++)
  1523.         ProcessFieldDeclaration(class_body -> ClassVariable(k));
  1524.  
  1525.     ThisType() -> MarkFieldMembersProcessed();
  1526.  
  1527.     return;
  1528. }
  1529.  
  1530.  
  1531. void Semantic::ProcessMembers(SemanticEnvironment *environment, AstClassBody *class_body)
  1532. {
  1533.     //
  1534.     //
  1535.     //
  1536.     state_stack.Push(environment);
  1537.     TypeSymbol *this_type = ThisType();
  1538. assert(! this_type -> ConstructorMembersProcessed() || this_type -> Bad());
  1539. assert(! this_type -> MethodMembersProcessed() || this_type -> Bad());
  1540. assert(! this_type -> FieldMembersProcessed() || this_type -> Bad());
  1541.  
  1542.     ProcessConstructorMembers(class_body);
  1543.     ProcessMethodMembers(class_body);
  1544.     ProcessFieldMembers(class_body);
  1545.  
  1546.     delete this_type -> innertypes_closure; // save some space !!!
  1547.     this_type -> innertypes_closure = NULL;
  1548.  
  1549.     if (! this_type -> IsTopLevel())
  1550.     {
  1551.         for (int i = 0; i < class_body -> NumStaticInitializers(); i++)
  1552.         {
  1553.              ReportSemError(SemanticError::STATIC_INITIALIZER_IN_INNER_CLASS,
  1554.                             class_body -> StaticInitializer(i) -> LeftToken(),
  1555.                             class_body -> StaticInitializer(i) -> RightToken(),
  1556.                             this_type -> Name(),
  1557.                             this_type -> FileLoc());
  1558.         }
  1559.     }
  1560.  
  1561.     for (int i = 0; i < this_type -> NumNestedTypes(); i++)
  1562.     {
  1563.         TypeSymbol *inner_type = this_type -> NestedType(i);
  1564.  
  1565.         if (inner_type -> ACC_INTERFACE())
  1566.         {
  1567.             AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) inner_type -> declaration;
  1568.  
  1569.             ProcessMembers(interface_declaration);
  1570.  
  1571.             if (! this_type -> IsTopLevel())
  1572.             {
  1573.                 //
  1574.                 // TODO: 1.1 assumption
  1575.                 //
  1576.                 // As every field in an interface is static, we presume that all interfaces
  1577.                 // should be treated as static entities
  1578.                 //
  1579.                 if (interface_declaration -> semantic_environment)
  1580.                 {
  1581.                     ReportSemError(SemanticError::STATIC_TYPE_IN_INNER_CLASS,
  1582.                                    interface_declaration -> identifier_token,
  1583.                                    interface_declaration -> identifier_token,
  1584.                                    lex_stream -> Name(interface_declaration -> identifier_token),
  1585.                                    this_type -> Name(),
  1586.                                    this_type -> FileLoc());
  1587.                 }
  1588.             }
  1589.         }
  1590.         else
  1591.         {
  1592.             AstClassDeclaration *class_declaration = (AstClassDeclaration *) inner_type -> declaration;
  1593.  
  1594.             ProcessMembers(class_declaration -> semantic_environment, class_declaration -> class_body);
  1595.  
  1596.             if (! this_type -> IsTopLevel())
  1597.             {
  1598.                 if (class_declaration -> semantic_environment && class_declaration -> semantic_environment -> Type() -> ACC_STATIC())
  1599.                 {
  1600.                     ReportSemError(SemanticError::STATIC_TYPE_IN_INNER_CLASS,
  1601.                                    class_declaration -> identifier_token,
  1602.                                    class_declaration -> identifier_token,
  1603.                                    lex_stream -> Name(class_declaration -> identifier_token),
  1604.                                    this_type -> Name(),
  1605.                                    this_type -> FileLoc());
  1606.                 }
  1607.             }
  1608.         }
  1609.     }
  1610.  
  1611.     state_stack.Pop();
  1612.  
  1613.     return;
  1614. }
  1615.  
  1616.  
  1617. inline void Semantic::ProcessMethodMembers(AstInterfaceDeclaration *interface_declaration)
  1618. {
  1619. assert(ThisType() -> HeaderProcessed());
  1620.  
  1621.     for (int k = 0; k < interface_declaration -> NumMethods(); k++)
  1622.         ProcessMethodDeclaration(interface_declaration -> Method(k));
  1623.  
  1624.     ThisType() -> MarkMethodMembersProcessed();
  1625.  
  1626.     return;
  1627. }
  1628.  
  1629.  
  1630. inline void Semantic::ProcessFieldMembers(AstInterfaceDeclaration *interface_declaration)
  1631. {
  1632. assert(ThisType() -> HeaderProcessed());
  1633.  
  1634.     for (int k = 0; k < interface_declaration -> NumClassVariables(); k++)
  1635.         ProcessFieldDeclaration(interface_declaration -> ClassVariable(k));
  1636.  
  1637.     ThisType() -> MarkFieldMembersProcessed();
  1638.  
  1639.     return;
  1640. }
  1641.  
  1642.  
  1643. void Semantic::ProcessMembers(AstInterfaceDeclaration *interface_declaration)
  1644. {
  1645.     //
  1646.     //
  1647.     //
  1648.     state_stack.Push(interface_declaration -> semantic_environment);
  1649.     TypeSymbol *this_type = ThisType();
  1650.  
  1651. assert(! this_type -> MethodMembersProcessed() || this_type -> Bad());
  1652. assert(! this_type -> FieldMembersProcessed() || this_type -> Bad());
  1653.  
  1654.     ProcessMethodMembers(interface_declaration);
  1655.     ProcessFieldMembers(interface_declaration);
  1656.  
  1657.     delete this_type -> innertypes_closure; // save some space !!!
  1658.     this_type -> innertypes_closure = NULL;
  1659.  
  1660.     for (int i = 0; i < this_type -> NumNestedTypes(); i++)
  1661.     {
  1662.         TypeSymbol *inner_type = this_type -> NestedType(i);
  1663.  
  1664.         if (inner_type -> ACC_INTERFACE())
  1665.         {
  1666.             AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) inner_type -> declaration;
  1667.             ProcessMembers(interface_declaration);
  1668.         }
  1669.         else
  1670.         {
  1671.             AstClassDeclaration *class_declaration = (AstClassDeclaration *) inner_type -> declaration;
  1672.             ProcessMembers(class_declaration -> semantic_environment, class_declaration -> class_body);
  1673.         }
  1674.     }
  1675.  
  1676.     state_stack.Pop();
  1677.  
  1678.     return;
  1679. }
  1680.  
  1681.  
  1682. //
  1683. // Pass 4: Process the field declarations at the top level of the types
  1684. //
  1685. void Semantic::CompleteSymbolTable(SemanticEnvironment *environment, LexStream::TokenIndex identifier_token, AstClassBody *class_body)
  1686. {
  1687.     if (compilation_unit -> BadCompilationUnitCast())
  1688.         return;
  1689.  
  1690.     state_stack.Push(environment);
  1691.     TypeSymbol *this_type = ThisType();
  1692. assert(this_type -> ConstructorMembersProcessed());
  1693. assert(this_type -> MethodMembersProcessed());
  1694. assert(this_type -> FieldMembersProcessed());
  1695.  
  1696.     //
  1697.     //
  1698.     //
  1699.     if (! this_type -> expanded_method_table)
  1700.         ComputeMethodsClosure(this_type, identifier_token);
  1701.  
  1702.     ExpandedMethodTable &expanded_table = *(this_type -> expanded_method_table);
  1703.     if (! this_type -> ACC_ABSTRACT())
  1704.     {
  1705.         //
  1706.         // Check that every abstract method that is inherited is overridden.
  1707.         //
  1708.         for (int i = 0; i < expanded_table.symbol_pool.Length(); i++)
  1709.         {
  1710.             MethodSymbol *method = expanded_table.symbol_pool[i] -> method_symbol;
  1711.  
  1712.             if (method -> ACC_ABSTRACT())
  1713.             {
  1714.                 TypeSymbol *containing_type = method -> containing_type;
  1715.                 if (containing_type != this_type)
  1716.                 {
  1717.                     //
  1718.                     // If the method is contained in an abstract method read from a class file,
  1719.                     // then it is possible that the abstract method is just out-of-date and needs
  1720.                     // to be recompiled.
  1721.                     //
  1722.                     ReportSemError((! containing_type -> ACC_INTERFACE()) &&
  1723.                                    (containing_type -> file_symbol && containing_type -> file_symbol -> IsClass())
  1724.                                         ? SemanticError::NON_ABSTRACT_TYPE_INHERITS_ABSTRACT_METHOD_FROM_ABSTRACT_CLASS
  1725.                                         : SemanticError::NON_ABSTRACT_TYPE_INHERITS_ABSTRACT_METHOD,
  1726.                                    identifier_token,
  1727.                                    identifier_token,
  1728.                                    method -> Header((Semantic *) this, identifier_token),
  1729.                                    containing_type -> ContainingPackage() -> PackageName(),
  1730.                                    containing_type -> ExternalName(),
  1731.                                    this_type -> ContainingPackage() -> PackageName(),
  1732.                                    this_type -> ExternalName());
  1733.                 }
  1734.             }
  1735.         }
  1736.  
  1737.         //
  1738.         // If the super class of this_type is abstract and it is contained in a
  1739.         // different package, check to see if its members include abstract methods
  1740.         // with default access. If so, we must issue error messages for them also
  1741.         // as they cannot be overridden.
  1742.         //
  1743.         if (this_type != control.Object() && this_type -> super -> ACC_ABSTRACT() &&
  1744.             (this_type -> ContainingPackage() != this_type -> super -> ContainingPackage()))
  1745.         {
  1746.             ExpandedMethodTable &super_expanded_table = *(this_type -> super -> expanded_method_table);
  1747.             for (int i = 0; i < super_expanded_table.symbol_pool.Length(); i++)
  1748.             {
  1749.                 MethodSymbol *method = super_expanded_table.symbol_pool[i] -> method_symbol;
  1750.  
  1751.                 if (method -> ACC_ABSTRACT() &&
  1752.                     (! (method -> ACC_PUBLIC() || method -> ACC_PROTECTED() || method -> ACC_PRIVATE())))
  1753.                 {
  1754.                     TypeSymbol *containing_type = method -> containing_type;
  1755.  
  1756.                     //
  1757.                     // If the method is contained in an abstract type read from a class file,
  1758.                     // then it is possible that the abstract method is just out-of-date and needs
  1759.                     // to be recompiled.
  1760.                     //
  1761.                     ReportSemError(SemanticError::NON_ABSTRACT_TYPE_CANNOT_OVERRIDE_DEFAULT_ABSTRACT_METHOD,
  1762.                                    identifier_token,
  1763.                                    identifier_token,
  1764.                                    method -> Header((Semantic *) this, identifier_token),
  1765.                                    containing_type -> ContainingPackage() -> PackageName(),
  1766.                                    containing_type -> ExternalName(),
  1767.                                    this_type -> ContainingPackage() -> PackageName(),
  1768.                                    this_type -> ExternalName());
  1769.                 }
  1770.             }
  1771.         }
  1772.     }
  1773.  
  1774.     for (int i = 0; i < expanded_table.symbol_pool.Length(); i++)
  1775.     {
  1776.         MethodShadowSymbol *method_shadow = expanded_table.symbol_pool[i];
  1777.  
  1778.         if (method_shadow -> NumConflicts() > 0)
  1779.         {
  1780.             MethodSymbol *method = method_shadow -> method_symbol;
  1781.  
  1782.             if (method -> containing_type == this_type)
  1783.             {
  1784.                 AstMethodDeclaration *method_declaration = (AstMethodDeclaration *) method -> method_or_constructor_declaration;
  1785.  
  1786.                 for (int k = 0; k < method_shadow -> NumConflicts(); k++)
  1787.                 {
  1788.                     MethodSymbol *hidden_method = method_shadow -> Conflict(k);
  1789.                     if (method -> containing_type != hidden_method -> containing_type) // the methods are not in the same type
  1790.                         CheckMethodOverride(method_declaration, hidden_method);
  1791.                 }
  1792.             }
  1793.             else
  1794.             {
  1795.                 AstClassDeclaration *class_declaration = (AstClassDeclaration *) this_type -> declaration;
  1796.  
  1797.                 for (int k = 0; k < method_shadow -> NumConflicts(); k++)
  1798.                 {
  1799.                     MethodSymbol *hidden_method = method_shadow -> Conflict(k);
  1800.                     if (method -> containing_type != hidden_method -> containing_type) // the methods are not in the same type
  1801.                         CheckMethodOverride(class_declaration, method, hidden_method);
  1802.                 }
  1803.  
  1804.                 if (! method -> ACC_ABSTRACT())
  1805.                 {
  1806.                     if (method -> ACC_STATIC())
  1807.                     {
  1808.                         ReportSemError(SemanticError::STATIC_OVERRIDE_ABSTRACT_EXTERNALLY,
  1809.                                        class_declaration -> identifier_token,
  1810.                                        (class_declaration -> NumInterfaces() > 0
  1811.                                              ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  1812.                                              : (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  1813.                                                                                : class_declaration -> identifier_token)),
  1814.                                        lex_stream -> Name(class_declaration -> identifier_token),
  1815.                                        method -> Header((Semantic *) this, identifier_token),
  1816.                                        method -> containing_type -> ContainingPackage() -> PackageName(),
  1817.                                        method -> containing_type -> ExternalName(),
  1818.                                        method_shadow -> Conflict(0) -> Header((Semantic *) this, identifier_token),
  1819.                                        method_shadow -> Conflict(0) -> containing_type -> ContainingPackage() -> PackageName(),
  1820.                                        method_shadow -> Conflict(0) -> containing_type -> ExternalName());
  1821.                     }
  1822.                 }
  1823.             }
  1824.  
  1825.             method_shadow -> RemoveConflicts();
  1826.         }
  1827.     }
  1828.  
  1829.     ProcessStaticInitializers(class_body);
  1830.  
  1831.     ProcessBlockInitializers(class_body);
  1832.  
  1833.     //
  1834.     // Reset the this_variable and this_method may have been set in
  1835.     // ProcessStaticInitializers and/or ProcessBlockInitializers.
  1836.     // Indicate that there is no method being currently compiled
  1837.     // in this environment.
  1838.     //
  1839.     ThisVariable() = NULL;
  1840.     ThisMethod() = NULL;
  1841.  
  1842.     //
  1843.     // Recursively process all inner types
  1844.     //
  1845.     for (int l = 0; l < this_type -> NumNestedTypes(); l++)
  1846.     {
  1847.         TypeSymbol *inner_type = this_type -> NestedType(l);
  1848.         if (inner_type -> ACC_INTERFACE())
  1849.             CompleteSymbolTable((AstInterfaceDeclaration *) inner_type -> declaration);
  1850.         else
  1851.         {
  1852.             AstClassDeclaration *class_declaration = (AstClassDeclaration *) inner_type -> declaration;
  1853.             CompleteSymbolTable(class_declaration -> semantic_environment,
  1854.                                 class_declaration -> identifier_token, class_declaration -> class_body);
  1855.         }
  1856.     }
  1857.  
  1858.     state_stack.Pop();
  1859.  
  1860.     return;
  1861. }
  1862.  
  1863.  
  1864. void Semantic::CompleteSymbolTable(AstInterfaceDeclaration *interface_declaration)
  1865. {
  1866.     if (compilation_unit -> BadCompilationUnitCast())
  1867.         return;
  1868.  
  1869.     state_stack.Push(interface_declaration -> semantic_environment);
  1870.     TypeSymbol *this_type = ThisType();
  1871. assert(this_type -> MethodMembersProcessed());
  1872. assert(this_type -> FieldMembersProcessed());
  1873.  
  1874.     //
  1875.     //
  1876.     //
  1877.     if (! this_type -> expanded_method_table)
  1878.         ComputeMethodsClosure(this_type, interface_declaration -> identifier_token);
  1879.  
  1880.     ExpandedMethodTable &expanded_table = *(this_type -> expanded_method_table);
  1881.     for (int i = 0; i < interface_declaration -> NumMethods(); i++)
  1882.     {
  1883.         AstMethodDeclaration *method_declaration = interface_declaration -> Method(i);
  1884.         MethodSymbol *method = method_declaration -> method_symbol;
  1885.  
  1886.         if (method)
  1887.         {
  1888.             MethodShadowSymbol *method_shadow = expanded_table.FindOverloadMethodShadow(method,
  1889.                                                                                         (Semantic *) this,
  1890.                                                                                         interface_declaration -> identifier_token);
  1891.             for (int k = 0; k < method_shadow -> NumConflicts(); k++)
  1892.             {
  1893.                 if (method_shadow -> method_symbol -> Type() != method_shadow -> Conflict(k) -> Type())
  1894.                 {
  1895.                     LexStream::TokenIndex token_location = method_declaration -> method_declarator -> identifier_token;
  1896.  
  1897.                     ReportSemError(SemanticError::MISMATCHED_INHERITED_METHOD,
  1898.                                    method_declaration -> method_declarator -> LeftToken(),
  1899.                                    method_declaration -> method_declarator -> RightToken(),
  1900.                                    method_shadow -> method_symbol -> Header((Semantic *) this, token_location),
  1901.                                    method_shadow -> Conflict(k) -> Header((Semantic *) this, token_location),
  1902.                                    method_shadow -> Conflict(k) -> containing_type -> ContainingPackage() -> PackageName(),
  1903.                                    method_shadow -> Conflict(k) -> containing_type -> ExternalName());
  1904.                 }
  1905.  
  1906.                 if (method_shadow -> method_symbol -> containing_type == this_type) // override ?
  1907.                     CheckInheritedMethodThrows(method_declaration, method_shadow -> Conflict(k));
  1908.             }
  1909.         }
  1910.     }
  1911.  
  1912.     //
  1913.     // Compute the set of final variables (all fields in an interface are final) in this type.
  1914.     //
  1915.     Tuple<VariableSymbol *> finals(this_type -> NumVariableSymbols());
  1916.     for (int j = 0; j < this_type -> NumVariableSymbols(); j++)
  1917.     {
  1918.         VariableSymbol *variable_symbol = this_type -> VariableSym(j);
  1919.         finals.Next() = variable_symbol;
  1920.     }
  1921.  
  1922.     //
  1923.     // Initialize each variable, in turn
  1924.     //
  1925.     for (int k = 0; k < interface_declaration -> NumClassVariables(); k++)
  1926.         InitializeVariable(interface_declaration -> ClassVariable(k), finals);
  1927.  
  1928.     //
  1929.     // Recursively process all inner types
  1930.     //
  1931.     for (int l = 0; l < this_type -> NumNestedTypes(); l++)
  1932.     {
  1933.         TypeSymbol *inner_type = this_type -> NestedType(l);
  1934.         if (inner_type -> ACC_INTERFACE())
  1935.             CompleteSymbolTable((AstInterfaceDeclaration *) inner_type -> declaration);
  1936.         else
  1937.         {
  1938.             AstClassDeclaration *class_declaration = (AstClassDeclaration *) inner_type -> declaration;
  1939.             CompleteSymbolTable(class_declaration -> semantic_environment,
  1940.                                 class_declaration -> identifier_token, class_declaration -> class_body);
  1941.         }
  1942.     }
  1943.  
  1944.     state_stack.Pop();
  1945.  
  1946.     return;
  1947. }
  1948.  
  1949.  
  1950. //
  1951. // Pass 5: Free up unneeded space.
  1952. //
  1953. void Semantic::CleanUp()
  1954. {
  1955.     for (int i = 0; i < compilation_unit -> NumTypeDeclarations(); i++)
  1956.     {
  1957.         TypeSymbol *type = NULL;
  1958.         Ast *type_declaration = compilation_unit -> TypeDeclaration(i);
  1959.         switch(type_declaration -> kind)
  1960.         {
  1961.             case Ast::CLASS:
  1962.             {
  1963.                 AstClassDeclaration *class_declaration = (AstClassDeclaration *) type_declaration;
  1964.                 if (class_declaration -> semantic_environment)
  1965.                     type = class_declaration -> semantic_environment -> Type();
  1966.                 break;
  1967.             }
  1968.             case Ast::INTERFACE:
  1969.             {
  1970.                 AstInterfaceDeclaration *interface_declaration = (AstInterfaceDeclaration *) type_declaration;
  1971.                 if (interface_declaration -> semantic_environment)
  1972.                     type = interface_declaration -> semantic_environment -> Type();
  1973.                 break;
  1974.             }
  1975.         }
  1976.  
  1977.         if (type)
  1978.             CleanUpType(type);
  1979.     }
  1980.  
  1981.     return;
  1982. }
  1983.  
  1984.  
  1985. void Semantic::CleanUpType(TypeSymbol *type)
  1986. {
  1987.     type -> DeleteAnonymousTypes();
  1988.     for (int i = 0; i < type -> NumNestedTypes(); i++)
  1989.         CleanUpType(type -> NestedType(i));
  1990.  
  1991.     type -> CompressSpace(); // space optimization
  1992.  
  1993.     for (int j = 0; j < type -> NumMethodSymbols(); j++)
  1994.         type -> MethodSym(j) -> CleanUp();
  1995.  
  1996.     delete type -> local;
  1997.     type -> local = NULL;
  1998.  
  1999.     delete type -> non_local;
  2000.     type -> non_local = NULL;
  2001.  
  2002.     delete type -> semantic_environment;
  2003.     type -> semantic_environment = NULL;
  2004.  
  2005.     type -> declaration = NULL;
  2006.  
  2007.     return;
  2008. }
  2009.  
  2010.  
  2011. //
  2012. //
  2013. //
  2014. void Semantic::ConvertUtf8ToUnicode(wchar_t *target, char *source, int len)
  2015. {
  2016.     for (int i = 0; i < len; i++, target++)
  2017.     {
  2018.         u1 ch = source[i];
  2019.  
  2020.         if ((ch & 0x80) == 0)
  2021.             *target = ch;
  2022.         else if ((ch & 0xE0) == 0xC0)
  2023.         {
  2024.             *target = ch & 0x1F;
  2025.             *target <<= 6;
  2026.             i++;
  2027.             ch = source[i] & 0x3F;
  2028.             *target += ch;
  2029.         }
  2030.         else if ((ch & 0xF0) == 0xE0)
  2031.         {
  2032.             *target = ch & 0x0F;
  2033.             *target <<= 6;
  2034.             i++;
  2035.             ch = source[i] & 0x3F;
  2036.             *target += ch;
  2037.  
  2038.             *target <<= 6;
  2039.             i++;
  2040.             ch = source[i] & 0x3F;
  2041.             *target += ch;
  2042.         }
  2043.         else
  2044.         {
  2045. cerr << "chaos: Damn, Caramba, Zut !!!\n";
  2046.         }
  2047.     }
  2048.  
  2049.     *target = U_NULL;
  2050.     return;
  2051. }
  2052.  
  2053.  
  2054. TypeSymbol *Semantic::ReadType(FileSymbol *file_symbol, PackageSymbol *package, NameSymbol *name_symbol, LexStream::TokenIndex tok)
  2055. {
  2056.     TypeSymbol *type;
  2057.  
  2058.     if (file_symbol && file_symbol -> IsJava())
  2059.     {
  2060.         if (! file_symbol -> semantic)
  2061.             control.ProcessHeaders(file_symbol);
  2062.         type = package -> FindTypeSymbol(name_symbol);
  2063.         if (! type)
  2064.         {
  2065.             type = package -> InsertOuterTypeSymbol(name_symbol);
  2066.             type -> outermost_type = type;
  2067.             type -> supertypes_closure = new SymbolSet;
  2068.             type -> subtypes = new SymbolSet;
  2069.             type -> semantic_environment = new SemanticEnvironment((Semantic *) this, type, NULL);
  2070.             if (type != control.Object())
  2071.                 type -> super = (type == control.Throwable() ? control.Object() : control.Throwable());
  2072.             type -> SetOwner(package);
  2073.             type -> SetSignature(control);
  2074.             type -> MarkBad();
  2075.             AddDefaultConstructor(type);
  2076.             type -> file_symbol = file_symbol;
  2077.             file_symbol -> types.Next() = type;
  2078.  
  2079.             ReportSemError(SemanticError::TYPE_NOT_FOUND,
  2080.                            tok,
  2081.                            tok,
  2082.                            type -> ContainingPackage() -> PackageName(),
  2083.                            type -> ExternalName());
  2084.         }
  2085.     }
  2086.     else // Read class file.
  2087.     {
  2088.         type = package -> InsertOuterTypeSymbol(name_symbol);
  2089.         type -> outermost_type = type;
  2090.         type -> supertypes_closure = new SymbolSet;
  2091.         type -> subtypes = new SymbolSet;
  2092.         type -> SetOwner(package);
  2093.         type -> SetSignature(control);
  2094.  
  2095.         if (file_symbol)
  2096.         {
  2097.             type -> file_symbol = file_symbol;
  2098.             type -> SetLocation();
  2099.  
  2100.             file_symbol -> package = package;
  2101.             file_symbol -> types.Next() = type;
  2102.  
  2103.             ReadClassFile(type, tok);
  2104.  
  2105. assert (! type -> IsNested());
  2106.             control.input_class_file_set.AddElement(file_symbol);
  2107.         }
  2108.         else
  2109.         {
  2110.             control.ProcessBadType(type);
  2111.             if (type != control.Object())
  2112.                 type -> super = (type == control.Throwable() ? control.Object() : control.Throwable());
  2113.             type -> MarkBad();
  2114.             AddDefaultConstructor(type);
  2115.  
  2116.             ReportSemError(SemanticError::TYPE_NOT_FOUND,
  2117.                            tok,
  2118.                            tok,
  2119.                            type -> ContainingPackage() -> PackageName(),
  2120.                            type -> ExternalName());
  2121.  
  2122.             if (package == control.unnamed_package)
  2123.             {
  2124.                 TypeSymbol *old_type = (TypeSymbol *) control.unnamed_package_types.Image(type -> Identity());
  2125.                 if (! old_type)
  2126.                     control.unnamed_package_types.AddElement(type);
  2127.                 else
  2128.                 {
  2129.                     ReportSemError(SemanticError::DUPLICATE_TYPE_DECLARATION,
  2130.                                    tok,
  2131.                                    tok,
  2132.                                    type -> Name(),
  2133.                                    old_type -> FileLoc());
  2134.                 }
  2135.             }
  2136.         }
  2137.     }
  2138.  
  2139.     return type;
  2140. }
  2141.  
  2142.  
  2143. TypeSymbol *Semantic::GetBadNestedType(TypeSymbol *type, LexStream::TokenIndex identifier_token)
  2144. {
  2145.     NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  2146.  
  2147.     TypeSymbol *outermost_type = type -> outermost_type;
  2148.     if (! outermost_type -> non_local)
  2149.         outermost_type -> non_local = new SymbolSet;
  2150.     if (! outermost_type -> local)
  2151.         outermost_type -> local = new SymbolSet;
  2152.  
  2153.     int length = type -> ExternalNameLength() + 1 + name_symbol -> NameLength(); // +1 for $,... +1 for $
  2154.     wchar_t *external_name = new wchar_t[length + 1]; // +1 for '\0';
  2155.     wcscpy(external_name, type -> ExternalName());
  2156.     wcscat(external_name, StringConstant::US__DS_);
  2157.     wcscat(external_name, name_symbol -> Name());
  2158.  
  2159.     TypeSymbol *inner_type = type -> InsertNestedTypeSymbol(name_symbol);
  2160.     inner_type -> outermost_type = type -> outermost_type;
  2161.     inner_type -> supertypes_closure = new SymbolSet;
  2162.     inner_type -> subtypes = new SymbolSet;
  2163.     inner_type -> SetExternalIdentity(control.FindOrInsertName(external_name, length));
  2164.     inner_type -> semantic_environment = new SemanticEnvironment((Semantic *) this,
  2165.                                                                  inner_type,
  2166.                                                                  type -> semantic_environment);
  2167.     inner_type -> super = control.Object();
  2168.     inner_type -> SetOwner(type);
  2169.     inner_type -> SetSignature(control);
  2170.     inner_type -> InsertThis(0);
  2171.     inner_type -> MarkBad();
  2172.     AddDefaultConstructor(inner_type);
  2173.  
  2174.     ReportSemError(SemanticError::TYPE_NOT_FOUND,
  2175.                    identifier_token,
  2176.                    identifier_token,
  2177.                    inner_type -> ContainingPackage() -> PackageName(),
  2178.                    inner_type -> ExternalName());
  2179.  
  2180.     delete [] external_name;
  2181.  
  2182.     return inner_type;
  2183. }
  2184.  
  2185.  
  2186. Symbol *Semantic::ProcessImportQualifiedName(AstExpression *name)
  2187. {
  2188.     PackageSymbol *package = NULL;
  2189.     TypeSymbol *type = NULL;
  2190.  
  2191.     AstFieldAccess *field_access = name -> FieldAccessCast();
  2192.     if (field_access)
  2193.     {
  2194.         Symbol *symbol = ProcessImportQualifiedName(field_access -> base);
  2195.  
  2196.         type = symbol -> TypeCast();
  2197.         if (type) // The base name is a type
  2198.         {
  2199.             if (! type -> NestedTypesProcessed())
  2200.                 type -> ProcessNestedTypeSignatures((Semantic *) this, field_access -> identifier_token);
  2201.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(field_access -> identifier_token);
  2202.             TypeSymbol *inner_type = type -> FindTypeSymbol(name_symbol);
  2203.             if (! inner_type)
  2204.                  inner_type = GetBadNestedType(type, field_access -> identifier_token);
  2205.             else if (! (inner_type -> ACC_PUBLIC() || inner_type -> ContainingPackage() == this_package))
  2206.                  ReportTypeInaccessible(field_access, inner_type);
  2207.             type = inner_type;
  2208.             field_access -> symbol = type; // save the type to which this expression was resolved for later use...
  2209.         }
  2210.         else 
  2211.         {
  2212.             package = symbol -> PackageCast();
  2213.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(field_access -> identifier_token);
  2214.             type = package -> FindTypeSymbol(name_symbol);
  2215.             if (! type)
  2216.             {
  2217.                 FileSymbol *file_symbol = Control::GetFile(package, name_symbol, control.option.depend);
  2218.                 if (file_symbol)
  2219.                     type = ReadType(file_symbol, package, name_symbol, field_access -> identifier_token);
  2220.             }
  2221.             else if (type -> SourcePending())
  2222.                  control.ProcessHeaders(type -> file_symbol);
  2223.  
  2224.             //
  2225.             // If the field_access was resolved to a type, save it later use.
  2226.             // Otherwise, assume the field_access is a package name.
  2227.             //
  2228.             if (type)
  2229.                  field_access -> symbol = type;
  2230.             else
  2231.             {
  2232.                 NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(field_access -> identifier_token);
  2233.                 PackageSymbol *subpackage = package -> FindPackageSymbol(name_symbol);
  2234.                 if (! subpackage)
  2235.                     subpackage = package -> InsertPackageSymbol(name_symbol);
  2236.                 control.FindPathsToDirectory(subpackage);
  2237.                 package = subpackage;
  2238.             }
  2239.         }
  2240.     }
  2241.     else
  2242.     {
  2243.         AstSimpleName *simple_name = name -> SimpleNameCast();
  2244. assert(simple_name);
  2245.  
  2246.         //
  2247.         // From the 1.1 document:
  2248.         //
  2249.         //    Nested classes of all sorts (top-level or inner) can be imported by either kind of
  2250.         //    import statement. Class names in import statements must be fully package
  2251.         //    qualified, and be resolvable without reference to inheritance relations...
  2252.         //
  2253.         if (compilation_unit -> package_declaration_opt)
  2254.         {
  2255.             type = FindSimpleNameType(this_package, simple_name -> identifier_token);
  2256.             //
  2257.             // If the type was not found, look for it in the unnamed package.
  2258.             // The relevant passages that justify this lookup are:
  2259.             // 6.5.4.11, 6.7, 7.4.2, 7.5.1
  2260.             //
  2261.             if (! type)
  2262.                 type = FindSimpleNameType(control.unnamed_package, simple_name -> identifier_token);
  2263.         }
  2264.         else type = FindSimpleNameType(control.unnamed_package, simple_name -> identifier_token);
  2265.  
  2266.         //
  2267.         // If the simple_name is a type, save it. Otherwise, assume it is a package
  2268.         //
  2269.         if (type)
  2270.         {
  2271.             if (! (type -> ACC_PUBLIC() || type -> ContainingPackage() == this_package))
  2272.                 ReportTypeInaccessible(name, type);
  2273.             simple_name -> symbol = type;
  2274.         }
  2275.         else
  2276.         {
  2277.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(simple_name -> identifier_token);
  2278.             package = control.external_table.FindPackageSymbol(name_symbol);
  2279.             if (! package)
  2280.                 package = control.external_table.InsertPackageSymbol(name_symbol, NULL);
  2281.             control.FindPathsToDirectory(package);
  2282.         }
  2283.     }
  2284.  
  2285.     return (type ? (Symbol *) type : (Symbol *) package);
  2286. }
  2287.  
  2288.  
  2289. Symbol *Semantic::ProcessPackageOrType(AstExpression *name)
  2290. {
  2291.     PackageSymbol *package = NULL;
  2292.     TypeSymbol *type = NULL;
  2293.  
  2294.     AstFieldAccess *field_access = name -> FieldAccessCast();
  2295.     if (field_access)
  2296.     {
  2297.         Symbol *symbol = ProcessPackageOrType(field_access -> base);
  2298.  
  2299.         type = symbol -> TypeCast();
  2300.         if (type) // The base name is a type
  2301.         {
  2302.             type = MustFindNestedType(type, field_access);
  2303.             field_access -> symbol = type; // save the type to which this expression was resolved for later use...
  2304.         }
  2305.         else 
  2306.         {
  2307.             package = symbol -> PackageCast();
  2308.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(field_access -> identifier_token);
  2309.             type = package -> FindTypeSymbol(name_symbol);
  2310.             if (! type)
  2311.             {
  2312.                 FileSymbol *file_symbol = Control::GetFile(package, name_symbol, control.option.depend);
  2313.                 if (file_symbol)
  2314.                     type = ReadType(file_symbol, package, name_symbol, field_access -> identifier_token);
  2315.             }
  2316.             else if (type -> SourcePending())
  2317.                  control.ProcessHeaders(type -> file_symbol);
  2318.  
  2319.             //
  2320.             // If the field access was resolved into a type, then save it.
  2321.             // Otherwise, assume it is a package
  2322.             //
  2323.             if (type)
  2324.                  field_access -> symbol = type; // save the type to which this expression was resolved for later use...
  2325.             else
  2326.             {
  2327.                 NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(field_access -> identifier_token);
  2328.                 PackageSymbol *subpackage = package -> FindPackageSymbol(name_symbol);
  2329.                 if (! subpackage)
  2330.                     subpackage = package -> InsertPackageSymbol(name_symbol);
  2331.                 control.FindPathsToDirectory(subpackage);
  2332.                 package = subpackage;
  2333.             }
  2334.         }
  2335.     }
  2336.     else
  2337.     {
  2338.         AstSimpleName *simple_name = name -> SimpleNameCast();
  2339. assert(simple_name);
  2340.         type = FindType(simple_name -> identifier_token);
  2341.         if (type)
  2342.         {
  2343.             TypeAccessCheck(simple_name, type);
  2344.             simple_name -> symbol = type;
  2345.         }
  2346.         else
  2347.         {
  2348.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(simple_name -> identifier_token);
  2349.             package = control.external_table.FindPackageSymbol(name_symbol);
  2350.             if (! package)
  2351.                 package = control.external_table.InsertPackageSymbol(name_symbol, NULL);
  2352.             control.FindPathsToDirectory(package);
  2353.         }
  2354.     }
  2355.  
  2356.     return (type ? (Symbol *) type : (Symbol *) package);
  2357. }
  2358.  
  2359.  
  2360. void Semantic::ProcessTypeImportOnDemandDeclaration(AstImportDeclaration *import_declaration)
  2361. {
  2362.     Symbol *symbol = ProcessImportQualifiedName(import_declaration -> name);
  2363.  
  2364.     PackageSymbol *package = symbol -> PackageCast();
  2365.     if (package && package -> directory.Length() == 0)
  2366.     {
  2367.         ReportSemError(SemanticError::PACKAGE_NOT_FOUND,
  2368.                        import_declaration -> name -> LeftToken(),
  2369.                        import_declaration -> name -> RightToken(),
  2370.                        package -> PackageName());
  2371.     }
  2372.  
  2373.     //
  2374.     // Two or more type-import-on-demand may name the same package; the effect is as if there
  2375.     // were only one such declaration.
  2376.     //
  2377.     for (int i = 0; i < import_on_demand_packages.Length(); i++)
  2378.     {
  2379.         if (symbol == import_on_demand_packages[i])
  2380.             return;
  2381.     }
  2382.  
  2383.     import_on_demand_packages.Next() = symbol;
  2384.  
  2385.     return;
  2386. }
  2387.  
  2388.  
  2389. //
  2390. // The Ast name is a name expression (either a qualified name or a simplename)
  2391. // FindFirstType traverses the name tree and returns the first subtree that it
  2392. // finds that matches a type. As a side-effect, each subtree that matches a package
  2393. // or a type has that package or type recorded in its "symbol" field.
  2394. //
  2395. AstExpression *Semantic::FindFirstType(Ast *name)
  2396. {
  2397.     AstExpression *name_expression = NULL;
  2398.  
  2399.     AstFieldAccess *field_access = name -> FieldAccessCast();
  2400.     if (field_access)
  2401.     {
  2402.         AstExpression *expr = FindFirstType(field_access -> base);
  2403.  
  2404.         if (expr -> symbol -> TypeCast()) // A subexpression has been found, pass it up
  2405.             name_expression = expr;
  2406.         else
  2407.         {
  2408.             PackageSymbol *package = expr -> symbol -> PackageCast();
  2409. assert(package);
  2410.             name_expression = field_access; // The relevant subexpression might be this field access...
  2411.  
  2412.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(field_access -> identifier_token);
  2413.             TypeSymbol *type = package -> FindTypeSymbol(name_symbol);
  2414.             if (type)
  2415.             {
  2416.                 if (type -> SourcePending())
  2417.                     control.ProcessHeaders(type -> file_symbol);
  2418.                 field_access -> symbol = type;
  2419.             }
  2420.             else
  2421.             {
  2422.                 FileSymbol *file_symbol = Control::GetFile(package, name_symbol, control.option.depend);
  2423.                 if (file_symbol)
  2424.                     field_access -> symbol = ReadType(file_symbol, package, name_symbol, field_access -> identifier_token);
  2425.                 else
  2426.                 {
  2427.                     PackageSymbol *subpackage = package -> FindPackageSymbol(name_symbol);
  2428.                     if (! subpackage)
  2429.                         subpackage = package -> InsertPackageSymbol(name_symbol);
  2430.                     control.FindPathsToDirectory(subpackage);
  2431.                     field_access -> symbol = subpackage;
  2432.                 }
  2433.             }
  2434.         }
  2435.     }
  2436.     else
  2437.     {
  2438.         AstSimpleName *simple_name = name -> SimpleNameCast();
  2439. assert(simple_name);
  2440.         simple_name -> symbol = ProcessPackageOrType(simple_name);
  2441.         name_expression = simple_name;
  2442.     }
  2443.  
  2444.     return name_expression;
  2445. }
  2446.  
  2447.  
  2448. TypeSymbol *Semantic::FindSimpleNameType(PackageSymbol *package, LexStream::TokenIndex identifier_token)
  2449. {
  2450.     NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  2451.     TypeSymbol *type = package -> FindTypeSymbol(name_symbol);
  2452.     if (type)
  2453.     {
  2454.         if (type -> SourcePending())
  2455.              control.ProcessHeaders(type -> file_symbol);
  2456.     }
  2457.     else
  2458.     {
  2459.         //
  2460.         // Check whether or not the type was declared in another compilation unit
  2461.         // in the main package.
  2462.         //
  2463.         FileSymbol *file_symbol = Control::GetFile(package, name_symbol, control.option.depend);
  2464.         if (file_symbol)
  2465.             type = ReadType(file_symbol, package, name_symbol, identifier_token);
  2466.     }
  2467.  
  2468.     return type;
  2469. }
  2470.  
  2471. void Semantic::ProcessSingleTypeImportDeclaration(AstImportDeclaration *import_declaration)
  2472. {
  2473.     Symbol *symbol = ProcessImportQualifiedName(import_declaration -> name);
  2474.     PackageSymbol *package = symbol -> PackageCast();
  2475.     if (package)
  2476.     {
  2477.         ReportSemError(SemanticError::UNKNOWN_QUALIFIED_NAME_BASE,
  2478.                        import_declaration -> name -> LeftToken(),
  2479.                        import_declaration -> name -> RightToken(),
  2480.                        package -> PackageName());
  2481.         return;
  2482.     }
  2483.  
  2484.     TypeSymbol *type = symbol -> TypeCast();
  2485.  
  2486.     //
  2487.     // If two single-type-import declarations in the same compilation unit attempt to
  2488.     // import types with the same simple name, then a compile-time error occurs, unless
  2489.     // the two types are the same type, in which case the duplicate declaration is ignored.
  2490.     //
  2491.     for (int i = 0; i < single_type_imports.Length(); i++)
  2492.     {
  2493.         if (type == single_type_imports[i])
  2494.             return;
  2495.     }
  2496.  
  2497.     TypeSymbol *old_type;
  2498.     int k;
  2499.     for (k = 0; k < compilation_unit -> NumTypeDeclarations(); k++)
  2500.     {
  2501.         AstClassDeclaration *class_declaration;
  2502.         AstInterfaceDeclaration *interface_declaration;
  2503.  
  2504.         if (class_declaration = compilation_unit -> TypeDeclaration(k) -> ClassDeclarationCast())
  2505.         {
  2506.             if (class_declaration -> semantic_environment)
  2507.             {
  2508.                 old_type = class_declaration -> semantic_environment -> Type();
  2509.                 if (old_type -> Identity() == type -> Identity())
  2510.                     break;
  2511.             }
  2512.         }
  2513.         else if (interface_declaration = compilation_unit -> TypeDeclaration(k) -> InterfaceDeclarationCast())
  2514.         {
  2515.             if (interface_declaration -> semantic_environment)
  2516.             {
  2517.                 old_type = interface_declaration -> semantic_environment -> Type();
  2518.                 if (old_type -> Identity() == type -> Identity())
  2519.                     break;
  2520.             }
  2521.         }
  2522.     }
  2523.  
  2524.     if (k < compilation_unit -> NumTypeDeclarations())
  2525.     {
  2526.         ReportSemError(SemanticError::DUPLICATE_TYPE_DECLARATION,
  2527.                        import_declaration -> name -> LeftToken(),
  2528.                        import_declaration -> name -> RightToken(),
  2529.                        lex_stream -> Name(import_declaration -> name -> RightToken()),
  2530.                        old_type -> FileLoc());
  2531.     }
  2532.     else
  2533.     {
  2534.         int i = 0;
  2535.         for (i = 0; i < compilation_unit -> NumImportDeclarations(); i++)
  2536.         {
  2537.             TypeSymbol *other_type = compilation_unit -> ImportDeclaration(i) -> name -> Type();
  2538.             if ((compilation_unit -> ImportDeclaration(i) == import_declaration) ||
  2539.                 (other_type && other_type -> Identity() == type -> Identity()))
  2540.                 break;
  2541.         }
  2542.  
  2543. assert(i < compilation_unit -> NumImportDeclarations());
  2544.         if (compilation_unit -> ImportDeclaration(i) == import_declaration) // No duplicate found
  2545.         {
  2546.             import_declaration -> name -> symbol = type;
  2547.             single_type_imports.Next() = type;
  2548.         }
  2549.         else
  2550.         {
  2551.             FileLocation file_location(lex_stream, compilation_unit -> ImportDeclaration(i) -> LeftToken());
  2552.             ReportSemError(SemanticError::DUPLICATE_TYPE_DECLARATION,
  2553.                            import_declaration -> name -> LeftToken(),
  2554.                            import_declaration -> name -> RightToken(),
  2555.                            lex_stream -> Name(import_declaration -> name -> RightToken()),
  2556.                            file_location.location);
  2557.         }
  2558.     }
  2559.  
  2560.     if (! (type -> ACC_PUBLIC() || type -> ContainingPackage() == this_package))
  2561.         ReportTypeInaccessible(import_declaration -> name, type);
  2562.  
  2563.     return;
  2564. }
  2565.  
  2566.  
  2567. void Semantic::ProcessFieldDeclaration(AstFieldDeclaration *field_declaration)
  2568. {
  2569.     TypeSymbol *this_type = ThisType();
  2570.     AccessFlags access_flags = (this_type -> ACC_INTERFACE()
  2571.                                            ? ProcessConstantModifiers(field_declaration)
  2572.                                            : ProcessFieldModifiers(field_declaration));
  2573.  
  2574.     //
  2575.     // New feature in java 1.2 that is undocumented in the 1.1 document.
  2576.     // A field may be declared static iff it is final and not blank-final...
  2577.     //
  2578.     if (access_flags.ACC_STATIC() && (! access_flags.ACC_FINAL()) && this_type -> IsInner())
  2579.     {
  2580.         AstModifier *modifier = NULL;
  2581.         for (int i = 0; i < field_declaration -> NumVariableModifiers(); i++)
  2582.         {
  2583.             if (field_declaration -> VariableModifier(i) -> kind == Ast::STATIC)
  2584.                 modifier = field_declaration -> VariableModifier(i);
  2585.         }
  2586.  
  2587. assert(modifier);
  2588.         ReportSemError(SemanticError::STATIC_FIELD_IN_INNER_CLASS,
  2589.                        modifier -> modifier_kind_token,
  2590.                        modifier -> modifier_kind_token);
  2591.     }
  2592.  
  2593.     //
  2594.     //
  2595.     //
  2596.     AstArrayType *array_type = field_declaration -> type -> ArrayTypeCast();
  2597.     Ast *actual_type = (array_type ? array_type -> type : field_declaration -> type);
  2598.     AstPrimitiveType *primitive_type = actual_type -> PrimitiveTypeCast();
  2599.     TypeSymbol *field_type = (primitive_type ? FindPrimitiveType(primitive_type) : MustFindType(actual_type));
  2600.     for (int i = 0; i < field_declaration -> NumVariableDeclarators(); i++)
  2601.     {
  2602.         AstVariableDeclarator *variable_declarator = field_declaration -> VariableDeclarator(i);
  2603.         AstVariableDeclaratorId *name = variable_declarator -> variable_declarator_name;
  2604.         NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(name -> identifier_token);
  2605.  
  2606.         if (this_type -> FindVariableSymbol(name_symbol))
  2607.         {
  2608.             ReportSemError(SemanticError::DUPLICATE_FIELD,
  2609.                            name -> identifier_token,
  2610.                            name -> identifier_token,
  2611.                            name_symbol -> Name(),
  2612.                            this_type -> Name());
  2613.         }
  2614.         else
  2615.         {
  2616.             VariableSymbol *variable = this_type -> InsertVariableSymbol(name_symbol);
  2617.             int num_dimensions = (array_type ? array_type -> NumBrackets() : 0) + name -> NumBrackets();
  2618.             if (num_dimensions == 0)
  2619.                  variable -> SetType(field_type);
  2620.             else variable -> SetType(field_type -> GetArrayType((Semantic *) this, num_dimensions));
  2621.             variable -> SetFlags(access_flags);
  2622.             variable -> SetOwner(this_type);
  2623.             variable -> declarator = variable_declarator;
  2624.             variable -> MarkIncomplete(); // the declaration of a field is not complete until its initializer
  2625.                                           // (if any) has been processed.
  2626.             variable_declarator -> symbol = variable;
  2627.         }
  2628.     }
  2629.  
  2630.     return;
  2631. }
  2632.  
  2633.  
  2634. void Semantic::GenerateLocalConstructor(MethodSymbol *constructor)
  2635. {
  2636.     TypeSymbol *local_type = constructor -> containing_type;
  2637.  
  2638.     //
  2639.     // Make up external name for constructor
  2640.     //
  2641.     wchar_t info[12],
  2642.             *str = &info[11];
  2643.     *str = U_NULL;
  2644.     int num = local_type -> NumGeneratedConstructors();
  2645.     do
  2646.     {
  2647.         *--str = (U_0 + num % 10);
  2648.         num /= 10;
  2649.     } while (num != 0);
  2650.  
  2651.     int length = 12 + (&info[11] - str); // +12 for constructor$
  2652.     wchar_t *external_name = new wchar_t[length + 1]; // +1 for '\0';
  2653.     wcscpy(external_name, StringConstant::US__constructor_DOLLAR);
  2654.     wcscat(external_name, str);
  2655.     constructor -> SetExternalIdentity(control.FindOrInsertName(external_name, length)); // Turn the constructor into a method
  2656.  
  2657.     delete [] external_name;
  2658.  
  2659.     //
  2660.     // Make generated constructor symbol. The associated symbol table will not contain too many elements.
  2661.     //
  2662.     BlockSymbol *block_symbol = new BlockSymbol(local_type -> NumConstructorParameters() +
  2663.                                                 constructor -> NumFormalParameters() + 3);
  2664.     block_symbol -> max_variable_index = 1; // All types need a spot for "this"
  2665.  
  2666.     MethodSymbol *local_constructor = local_type -> LocalConstructorOverload(constructor);
  2667.     local_constructor -> method_or_constructor_declaration = constructor -> method_or_constructor_declaration;
  2668.     local_constructor -> SetType(control.void_type);
  2669.     local_constructor -> SetContainingType(local_type);
  2670.     local_constructor -> SetBlockSymbol(block_symbol);
  2671.     ((AccessFlags *) local_constructor) -> access_flags = ((AccessFlags *) constructor) -> access_flags;
  2672.     for (int i = 0; i < constructor -> NumThrows(); i++)
  2673.         local_constructor -> AddThrows(constructor -> Throws(i));
  2674.  
  2675.     for (int j = 0; j < local_type -> NumConstructorParameters(); j++)
  2676.     {
  2677.         VariableSymbol *param = local_type -> ConstructorParameter(j),
  2678.                        *symbol = block_symbol -> InsertVariableSymbol(param -> Identity());
  2679.         symbol -> SetType(param -> Type());
  2680.         symbol -> SetOwner(local_constructor);
  2681.         symbol -> SetExternalIdentity(param -> ExternalIdentity());
  2682.         symbol -> SetLocalVariableIndex(block_symbol -> max_variable_index++);
  2683.         if (symbol -> Type() == control.long_type || symbol -> Type() == control.double_type)
  2684.             block_symbol -> max_variable_index++;
  2685.         local_constructor -> AddFormalParameter(symbol);
  2686.     }
  2687.  
  2688.     //
  2689.     // Add all the parameters from the original constructor to the symbol
  2690.     // table of the local constructor. However, only mark them complete and
  2691.     // do not yet assign a number to them. This will be done after we know
  2692.     // how many extra "local" variable shadows are needed.
  2693.     //
  2694.     for (int k = 0; k < constructor -> NumFormalParameters(); k++)
  2695.     {
  2696.         VariableSymbol *param = constructor -> FormalParameter(k),
  2697.                        *symbol = block_symbol -> InsertVariableSymbol(param -> Identity());
  2698.         symbol -> SetType(param -> Type());
  2699.         symbol -> SetOwner(local_constructor);
  2700.         symbol -> MarkComplete();
  2701.     }
  2702.  
  2703.     local_type -> AddGeneratedConstructor(local_constructor);
  2704.  
  2705.     return;
  2706. }
  2707.  
  2708.  
  2709. void Semantic::ProcessConstructorDeclaration(AstConstructorDeclaration *constructor_declaration)
  2710. {
  2711.     TypeSymbol *this_type = ThisType();
  2712.     if (this_type -> Anonymous())
  2713.     {
  2714.         ReportSemError(SemanticError::CONSTRUCTOR_FOUND_IN_ANONYMOUS_CLASS,
  2715.                        constructor_declaration -> LeftToken(),
  2716.                        constructor_declaration -> RightToken());
  2717.         return;
  2718.     }
  2719.  
  2720.     AccessFlags access_flags = ProcessConstructorModifiers(constructor_declaration);
  2721.  
  2722.     AstMethodDeclarator *constructor_declarator = constructor_declaration -> constructor_declarator;
  2723.     NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(constructor_declarator -> identifier_token);
  2724.     wchar_t *constructor_name = lex_stream -> Name(constructor_declarator -> identifier_token);
  2725.  
  2726.     if (lex_stream -> NameSymbol(constructor_declarator -> identifier_token) != this_type -> Identity())
  2727.     {
  2728.         ReportSemError(SemanticError::MISMATCHED_CONSTRUCTOR_NAME,
  2729.                        constructor_declarator -> identifier_token,
  2730.                        constructor_declarator -> identifier_token,
  2731.                        constructor_name,
  2732.                        this_type -> Name());
  2733.         constructor_name = this_type -> Name(); // assume the proper name !
  2734.     }
  2735.  
  2736.     //
  2737.     // As the body of the constructor may not have been parsed yet, we estimate a size
  2738.     // for its symbol table based on the number of lines in the body + a margin for one-liners.
  2739.     //
  2740.     AstConstructorBlock *block = constructor_declaration -> constructor_body -> ConstructorBlockCast();
  2741.     BlockSymbol *block_symbol = new BlockSymbol(constructor_declarator -> NumFormalParameters() + 3);
  2742.     block_symbol -> max_variable_index = 1; // All types need a spot for "this".
  2743.  
  2744.     ProcessFormalParameters(block_symbol, constructor_declarator);
  2745.  
  2746.     //
  2747.     // Note that constructors are always named "<init>"
  2748.     //
  2749.     MethodSymbol *constructor = this_type -> FindMethodSymbol(control.init_name_symbol);
  2750.  
  2751.     if (! constructor) // there exists a constructor already in type -> table.
  2752.          constructor = this_type -> InsertConstructorSymbol(control.init_name_symbol);
  2753.     else
  2754.     {
  2755.         if (this_type -> FindOverloadMethod(constructor, constructor_declarator))
  2756.         {
  2757.             ReportSemError(SemanticError::DUPLICATE_CONSTRUCTOR,
  2758.                            constructor_declarator -> LeftToken(),
  2759.                            constructor_declarator -> RightToken(),
  2760.                            this_type -> Name());
  2761.             delete block_symbol;
  2762.             return;
  2763.         }
  2764.  
  2765.         constructor = this_type -> Overload(constructor);
  2766.     }
  2767.  
  2768.     //
  2769.     // If the method is not static, leave a slot for the "this" pointer.
  2770.     //
  2771.     constructor -> SetType(control.void_type);
  2772.     constructor -> SetFlags(access_flags);
  2773.     constructor -> SetContainingType(this_type);
  2774.     constructor -> SetBlockSymbol(block_symbol);
  2775.     constructor -> method_or_constructor_declaration = constructor_declaration;
  2776.  
  2777.     VariableSymbol *this0_variable = NULL;
  2778.     if (this_type -> IsInner())
  2779.     {
  2780.         this0_variable = block_symbol -> InsertVariableSymbol(control.this0_name_symbol);
  2781.         this0_variable -> SetType(this_type -> ContainingType());
  2782.         this0_variable -> SetOwner(constructor);
  2783.         this0_variable -> SetLocalVariableIndex(block_symbol -> max_variable_index++);
  2784.     }
  2785.  
  2786.     for (int i = 0; i < constructor_declarator -> NumFormalParameters(); i++)
  2787.     {
  2788.         AstFormalParameter *parameter = constructor_declarator -> FormalParameter(i);
  2789.         VariableSymbol *symbol = parameter -> parameter_symbol;
  2790.  
  2791.         symbol -> SetOwner(constructor);
  2792.         symbol -> SetLocalVariableIndex(block_symbol -> max_variable_index++);
  2793.         if (symbol -> Type() == control.long_type || symbol -> Type() == control.double_type)
  2794.             block_symbol -> max_variable_index++;
  2795.         symbol -> declarator = parameter -> variable_declarator_name;
  2796.         constructor -> AddFormalParameter(symbol);
  2797.     }
  2798.  
  2799.     constructor -> SetSignature(control, this0_variable);
  2800.  
  2801.     for (int k = 0; k < constructor_declaration -> NumThrows(); k++)
  2802.     {
  2803.         AstExpression *throw_expression = constructor_declaration -> Throw(k);
  2804.         TypeSymbol *throw_type = MustFindType(throw_expression);
  2805.         throw_expression -> symbol = throw_type;
  2806.         constructor -> AddThrows(throw_type);
  2807.     }
  2808.  
  2809.     constructor_declaration -> constructor_symbol = constructor; // save for processing bodies later.
  2810.  
  2811.     if (this_type -> IsLocal())
  2812.         GenerateLocalConstructor(constructor);
  2813.  
  2814.     return;
  2815. }
  2816.  
  2817.  
  2818. void Semantic::AddDefaultConstructor(TypeSymbol *type)
  2819. {
  2820.     MethodSymbol *constructor = type -> InsertConstructorSymbol(control.init_name_symbol);
  2821.  
  2822.     BlockSymbol *block_symbol = new BlockSymbol(1); // TODO: make sure this size is right !!!
  2823.     block_symbol -> max_variable_index = 1; // All types need a spot for "this"
  2824.  
  2825.     constructor -> SetType(control.void_type);
  2826.     constructor -> SetContainingType(type);
  2827.     constructor -> SetBlockSymbol(block_symbol);
  2828.     if (type -> ACC_PUBLIC())
  2829.         constructor -> SetACC_PUBLIC();
  2830.  
  2831.     VariableSymbol *this0_variable = NULL;
  2832.     if (type -> IsInner())
  2833.     {
  2834.         this0_variable = block_symbol -> InsertVariableSymbol(control.this0_name_symbol);
  2835.         this0_variable -> SetType(type -> ContainingType());
  2836.         this0_variable -> SetOwner(constructor);
  2837.         this0_variable -> SetLocalVariableIndex(block_symbol -> max_variable_index++);
  2838.     }
  2839.  
  2840.     constructor -> SetSignature(control, this0_variable);
  2841.  
  2842.     AstClassDeclaration *class_declaration = (type -> declaration ? type -> declaration -> ClassDeclarationCast()
  2843.                                                                   : (AstClassDeclaration *) NULL);
  2844.     if (class_declaration)
  2845.     {
  2846.         AstClassBody *class_body = class_declaration -> class_body;
  2847.         LexStream::TokenIndex left_loc  = class_declaration -> identifier_token,
  2848.                               right_loc = (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  2849.                                                                           : class_declaration -> identifier_token);
  2850.  
  2851.         AstMethodDeclarator *method_declarator       = compilation_unit -> ast_pool -> GenMethodDeclarator();
  2852.         method_declarator -> identifier_token        = left_loc;
  2853.         method_declarator -> left_parenthesis_token  = left_loc;
  2854.         method_declarator -> right_parenthesis_token = right_loc;
  2855.  
  2856.         AstSuperCall *super_call = NULL;
  2857.         if (type != control.Object())
  2858.         {
  2859.             super_call                            = compilation_unit -> ast_pool -> GenSuperCall();
  2860.             super_call -> base_opt                = NULL;
  2861.             super_call -> dot_token_opt           = left_loc;
  2862.             super_call -> super_token             = left_loc;
  2863.             super_call -> left_parenthesis_token  = left_loc;
  2864.             super_call -> right_parenthesis_token = right_loc;
  2865.             super_call -> semicolon_token         = right_loc;
  2866.         }
  2867.  
  2868.         AstReturnStatement *return_statement = compilation_unit -> ast_pool -> GenReturnStatement();
  2869.         return_statement -> return_token = left_loc;
  2870.         return_statement -> expression_opt = NULL;
  2871.         return_statement -> semicolon_token = left_loc;
  2872.         return_statement -> is_reachable = true;
  2873.  
  2874.         AstBlock *block = compilation_unit -> ast_pool -> GenBlock();
  2875.         block -> AllocateBlockStatements(1); // this block contains one statement
  2876.         block -> left_brace_token  = left_loc;
  2877.         block -> right_brace_token = right_loc;
  2878.  
  2879.         block -> is_reachable = true;
  2880.         block -> can_complete_normally = false;
  2881.         block -> AddStatement(return_statement);
  2882.  
  2883.         AstConstructorBlock *constructor_block                   = compilation_unit -> ast_pool -> GenConstructorBlock();
  2884.         constructor_block -> left_brace_token                    = left_loc;
  2885.         constructor_block -> explicit_constructor_invocation_opt = super_call;
  2886.         constructor_block -> block                               = block;
  2887.         constructor_block -> right_brace_token                   = right_loc;
  2888.  
  2889.         AstConstructorDeclaration *constructor_declaration = compilation_unit -> ast_pool -> GenConstructorDeclaration();
  2890.         constructor_declaration -> constructor_declarator   = method_declarator;
  2891.         constructor_declaration -> constructor_body         = constructor_block;
  2892.  
  2893.         constructor_declaration -> constructor_symbol = constructor;
  2894.         constructor -> method_or_constructor_declaration = constructor_declaration;
  2895.         class_body -> default_constructor = constructor_declaration;
  2896.  
  2897.         if (type -> IsLocal())
  2898.             GenerateLocalConstructor(constructor);
  2899.     }
  2900.  
  2901.     return;
  2902. }
  2903.  
  2904.  
  2905. void Semantic::CheckInheritedMethodThrows(AstMethodDeclaration *method_declaration, MethodSymbol *method)
  2906. {
  2907.     for (int i = 0; i < method_declaration -> NumThrows(); i++)
  2908.     {
  2909.         AstExpression *name = method_declaration -> Throw(i);
  2910.         TypeSymbol *exception = (TypeSymbol *) name -> symbol;
  2911.  
  2912.         if (CheckedException(exception))
  2913.         {
  2914.             int k;
  2915.             for (k = method -> NumThrows((Semantic *) this, name -> RightToken()) - 1; k >= 0; k--)
  2916.             {
  2917.                 if (exception -> IsSubclass(method -> Throws(k)))
  2918.                     break;
  2919.             }
  2920.  
  2921.             if (k < 0)
  2922.             {
  2923.                 ReportSemError(SemanticError::MISMATCHED_OVERRIDDEN_EXCEPTION,
  2924.                                name -> LeftToken(),
  2925.                                name -> RightToken(),
  2926.                                exception -> Name(),
  2927.                                method -> Header((Semantic *) this, name -> RightToken()),
  2928.                                method -> containing_type -> ContainingPackage() -> PackageName(),
  2929.                                method -> containing_type -> ExternalName());
  2930.             }
  2931.         }
  2932.     }
  2933.  
  2934.     return;
  2935. }
  2936.  
  2937.  
  2938. void Semantic::CheckMethodOverride(AstMethodDeclaration *method_declaration, MethodSymbol *hidden_method)
  2939. {
  2940.     AstMethodDeclarator *method_declarator = method_declaration -> method_declarator;
  2941.     MethodSymbol *method = method_declaration -> method_symbol;
  2942.     LexStream::TokenIndex token_location = method_declaration -> method_declarator -> identifier_token;
  2943.  
  2944.     if (hidden_method -> Type() != method -> Type())
  2945.         ReportSemError(SemanticError::MISMATCHED_INHERITED_METHOD,
  2946.                        method_declarator -> LeftToken(),
  2947.                        method_declarator -> RightToken(),
  2948.                        method -> Header((Semantic *) this, token_location),
  2949.                        hidden_method -> Header((Semantic *) this, token_location),
  2950.                        hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  2951.                        hidden_method -> containing_type -> ExternalName());
  2952.     if (hidden_method -> IsFinal() || hidden_method -> ACC_PRIVATE()) // Merged because same kind of message. See error.cpp
  2953.         ReportSemError(hidden_method -> IsFinal() ? SemanticError::FINAL_METHOD_OVERRIDE : SemanticError::PRIVATE_METHOD_OVERRIDE,
  2954.                        method_declarator -> LeftToken(),
  2955.                        method_declarator -> RightToken(),
  2956.                        method -> Header((Semantic *) this, token_location),
  2957.                        hidden_method -> Header((Semantic *) this, token_location),
  2958.                        hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  2959.                        hidden_method -> containing_type -> ExternalName());
  2960.  
  2961.     if (method -> ACC_STATIC() != hidden_method -> ACC_STATIC())
  2962.     {
  2963.         if (method -> ACC_STATIC())
  2964.              ReportSemError(SemanticError::INSTANCE_METHOD_OVERRIDE,
  2965.                             method_declarator -> LeftToken(),
  2966.                             method_declarator -> RightToken(),
  2967.                             method -> Header((Semantic *) this, token_location),
  2968.                             hidden_method -> Header((Semantic *) this, token_location),
  2969.                             hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  2970.                             hidden_method -> containing_type -> ExternalName());
  2971.         else ReportSemError(SemanticError::CLASS_METHOD_OVERRIDE,
  2972.                             method_declarator -> LeftToken(),
  2973.                             method_declarator -> RightToken(),
  2974.                             method -> Header((Semantic *) this, token_location),
  2975.                             hidden_method -> Header((Semantic *) this, token_location),
  2976.                             hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  2977.                             hidden_method -> containing_type -> ExternalName());
  2978.     }
  2979.  
  2980.     if (hidden_method -> ACC_PUBLIC())
  2981.     {
  2982.         if (! method -> ACC_PUBLIC())
  2983.             ReportSemError(SemanticError::BAD_ACCESS_METHOD_OVERRIDE,
  2984.                            method_declarator -> LeftToken(),
  2985.                            method_declarator -> RightToken(),
  2986.                            method -> Header((Semantic *) this, token_location),
  2987.                            (method -> ACC_PRIVATE() ? StringConstant::US_private : (method -> ACC_PROTECTED() ? StringConstant::US_protected : StringConstant::US_default)),
  2988.                            hidden_method -> Header((Semantic *) this, token_location),
  2989.                            StringConstant::US_public,
  2990.                            hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  2991.                            hidden_method -> containing_type -> ExternalName());
  2992.     }
  2993.     else if (hidden_method -> ACC_PROTECTED())
  2994.     {
  2995.         if (! (method -> ACC_PROTECTED() || method -> ACC_PUBLIC()))
  2996.              ReportSemError(SemanticError::BAD_ACCESS_METHOD_OVERRIDE,
  2997.                             method_declarator -> LeftToken(),
  2998.                             method_declarator -> RightToken(),
  2999.                             method -> Header((Semantic *) this, token_location),
  3000.                             StringConstant::US_default,
  3001.                             hidden_method -> Header((Semantic *) this, token_location),
  3002.                             StringConstant::US_protected,
  3003.                             hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3004.                             hidden_method -> containing_type -> ExternalName());
  3005.     }
  3006.     else if (method -> ACC_PRIVATE()) // The hidden_method method must have default access as it cannot be private...
  3007.     {
  3008.          ReportSemError(SemanticError::BAD_ACCESS_METHOD_OVERRIDE,
  3009.                         method_declarator -> LeftToken(),
  3010.                         method_declarator -> RightToken(),
  3011.                         method -> Header((Semantic *) this, token_location),
  3012.                         StringConstant::US_private,
  3013.                         hidden_method -> Header((Semantic *) this, token_location),
  3014.                         StringConstant::US_default,
  3015.                         hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3016.                         hidden_method -> containing_type -> ExternalName());
  3017.     }
  3018.  
  3019.     CheckInheritedMethodThrows(method_declaration, hidden_method);
  3020.  
  3021.     return;
  3022. }
  3023.  
  3024.  
  3025. void Semantic::CheckInheritedMethodThrows(AstClassDeclaration *class_declaration, MethodSymbol *method, MethodSymbol *hidden_method)
  3026. {
  3027.     for (int i = method -> NumThrows((Semantic *) this, class_declaration -> identifier_token) - 1; i >= 0; i--)
  3028.     {
  3029.         TypeSymbol *exception = method -> Throws(i);
  3030.  
  3031.         if (CheckedException(exception))
  3032.         {
  3033.             int k;
  3034.             for (k = hidden_method -> NumThrows((Semantic *) this, class_declaration -> identifier_token) - 1; k >= 0; k--)
  3035.             {
  3036.                 if (exception -> IsSubclass(hidden_method -> Throws(k)))
  3037.                     break;
  3038.             }
  3039.  
  3040.             if (k < 0)
  3041.             {
  3042.                 ReportSemError(SemanticError::MISMATCHED_OVERRIDDEN_EXCEPTION_EXTERNALLY,
  3043.                                class_declaration -> identifier_token,
  3044.                                (class_declaration -> NumInterfaces() > 0
  3045.                                      ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  3046.                                      : (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  3047.                                                                        : class_declaration -> identifier_token)),
  3048.                                lex_stream -> Name(class_declaration -> identifier_token),
  3049.                                exception -> Name(),
  3050.                                method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3051.                                hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3052.                                hidden_method -> containing_type -> ExternalName(),
  3053.                                hidden_method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3054.                                method -> containing_type -> ContainingPackage() -> PackageName(),
  3055.                                method -> containing_type -> ExternalName());
  3056.             }
  3057.         }
  3058.     }
  3059.  
  3060.     return;
  3061. }
  3062.  
  3063.  
  3064. void Semantic::CheckMethodOverride(AstClassDeclaration *class_declaration, MethodSymbol *method, MethodSymbol *hidden_method)
  3065. {
  3066.     if (hidden_method -> Type() != method -> Type())
  3067.         ReportSemError(SemanticError::MISMATCHED_INHERITED_METHOD_EXTERNALLY,
  3068.                        class_declaration -> identifier_token,
  3069.                        (class_declaration -> NumInterfaces() > 0
  3070.                                            ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  3071.                                            : (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  3072.                                                                              : class_declaration -> identifier_token)),
  3073.                        lex_stream -> Name(class_declaration -> identifier_token),
  3074.                        method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3075.                        method -> containing_type -> ContainingPackage() -> PackageName(),
  3076.                        method -> containing_type -> ExternalName(),
  3077.                        hidden_method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3078.                        hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3079.                        hidden_method -> containing_type -> ExternalName());
  3080.     if (hidden_method -> IsFinal() || hidden_method -> ACC_PRIVATE()) // Merged because same kind of message. See error.cpp
  3081.         ReportSemError(hidden_method -> IsFinal() ? SemanticError::FINAL_METHOD_OVERRIDE_EXTERNALLY
  3082.                                                   : SemanticError::PRIVATE_METHOD_OVERRIDE_EXTERNALLY,
  3083.                        class_declaration -> identifier_token,
  3084.                        (class_declaration -> NumInterfaces() > 0
  3085.                                            ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  3086.                                            : (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  3087.                                                                              : class_declaration -> identifier_token)),
  3088.                        lex_stream -> Name(class_declaration -> identifier_token),
  3089.                        method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3090.                        method -> containing_type -> ContainingPackage() -> PackageName(),
  3091.                        method -> containing_type -> ExternalName(),
  3092.                        hidden_method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3093.                        hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3094.                        hidden_method -> containing_type -> ExternalName());
  3095.  
  3096.     if (method -> ACC_STATIC() != hidden_method -> ACC_STATIC())
  3097.     {
  3098.         if (method -> ACC_STATIC())
  3099.              ReportSemError(SemanticError::INSTANCE_METHOD_OVERRIDE_EXTERNALLY,
  3100.                             class_declaration -> identifier_token,
  3101.                             (class_declaration -> NumInterfaces() > 0
  3102.                                                 ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  3103.                                                 : (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  3104.                                                                                   : class_declaration -> identifier_token)),
  3105.                             lex_stream -> Name(class_declaration -> identifier_token),
  3106.                             method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3107.                             method -> containing_type -> ContainingPackage() -> PackageName(),
  3108.                             method -> containing_type -> ExternalName(),
  3109.                             hidden_method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3110.                             hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3111.                             hidden_method -> containing_type -> ExternalName());
  3112.         else ReportSemError(SemanticError::CLASS_METHOD_OVERRIDE_EXTERNALLY,
  3113.                             class_declaration -> identifier_token,
  3114.                             (class_declaration -> NumInterfaces() > 0
  3115.                                                 ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  3116.                                                 : (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  3117.                                                                                   : class_declaration -> identifier_token)),
  3118.                             lex_stream -> Name(class_declaration -> identifier_token),
  3119.                             method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3120.                             method -> containing_type -> ContainingPackage() -> PackageName(),
  3121.                             method -> containing_type -> ExternalName(),
  3122.                             hidden_method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3123.                             hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3124.                             hidden_method -> containing_type -> ExternalName());
  3125.     }
  3126.  
  3127.     if (hidden_method -> ACC_PUBLIC())
  3128.     {
  3129.         if (! method -> ACC_PUBLIC())
  3130.             ReportSemError(SemanticError::BAD_ACCESS_METHOD_OVERRIDE_EXTERNALLY,
  3131.                            class_declaration -> identifier_token,
  3132.                            (class_declaration -> NumInterfaces() > 0
  3133.                                                ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  3134.                                                : (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  3135.                                                                                  : class_declaration -> identifier_token)),
  3136.                            lex_stream -> Name(class_declaration -> identifier_token),
  3137.                            method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3138.                            (method -> ACC_PRIVATE() ? StringConstant::US_private
  3139.                                                     : (method -> ACC_PROTECTED() ? StringConstant::US_protected
  3140.                                                                                  : StringConstant::US_default)),
  3141.                            method -> containing_type -> ContainingPackage() -> PackageName(),
  3142.                            method -> containing_type -> ExternalName(),
  3143.                            hidden_method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3144.                            StringConstant::US_public,
  3145.                            hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3146.                            hidden_method -> containing_type -> ExternalName());
  3147.     }
  3148.     else if (hidden_method -> ACC_PROTECTED())
  3149.     {
  3150.         if (! (method -> ACC_PROTECTED() || method -> ACC_PUBLIC()))
  3151.              ReportSemError(SemanticError::BAD_ACCESS_METHOD_OVERRIDE,
  3152.                             class_declaration -> identifier_token,
  3153.                             (class_declaration -> NumInterfaces() > 0
  3154.                                                 ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  3155.                                                 : (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  3156.                                                                                   : class_declaration -> identifier_token)),
  3157.                             lex_stream -> Name(class_declaration -> identifier_token),
  3158.                             method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3159.                             StringConstant::US_default,
  3160.                             method -> containing_type -> ContainingPackage() -> PackageName(),
  3161.                             method -> containing_type -> ExternalName(),
  3162.                             hidden_method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3163.                             StringConstant::US_protected,
  3164.                             hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3165.                             hidden_method -> containing_type -> ExternalName());
  3166.     }
  3167.     else if (method -> ACC_PRIVATE()) // The hidden_method method must have default access as it cannot be private...
  3168.     {
  3169.          ReportSemError(SemanticError::BAD_ACCESS_METHOD_OVERRIDE_EXTERNALLY,
  3170.                         class_declaration -> identifier_token,
  3171.                         (class_declaration -> NumInterfaces() > 0
  3172.                                             ? class_declaration -> Interface(class_declaration -> NumInterfaces() - 1) -> RightToken()
  3173.                                             : (class_declaration -> super_opt ? class_declaration -> super_opt -> RightToken()
  3174.                                                                               : class_declaration -> identifier_token)),
  3175.                         lex_stream -> Name(class_declaration -> identifier_token),
  3176.                         method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3177.                         StringConstant::US_private,
  3178.                         method -> containing_type -> ContainingPackage() -> PackageName(),
  3179.                         method -> containing_type -> ExternalName(),
  3180.                         hidden_method -> Header((Semantic *) this, class_declaration -> identifier_token),
  3181.                         StringConstant::US_default,
  3182.                         hidden_method -> containing_type -> ContainingPackage() -> PackageName(),
  3183.                         hidden_method -> containing_type -> ExternalName());
  3184.     }
  3185.  
  3186.     CheckInheritedMethodThrows(class_declaration, method, hidden_method);
  3187.  
  3188.     return;
  3189. }
  3190.  
  3191.  
  3192. void Semantic::AddInheritedTypes(TypeSymbol *base_type, TypeSymbol *super_type)
  3193. {
  3194.     ExpandedTypeTable &base_expanded_table = *(base_type -> expanded_type_table),
  3195.                       &super_expanded_table = *(super_type -> expanded_type_table);
  3196.  
  3197.     for (int j = 0; j < super_expanded_table.symbol_pool.Length(); j++)
  3198.     {
  3199.         TypeShadowSymbol *type_shadow_symbol = super_expanded_table.symbol_pool[j];
  3200.         TypeSymbol *type_symbol = type_shadow_symbol -> type_symbol;
  3201.  
  3202.         //
  3203.         // Note that since all fields in an interface are implicitly public, all other fields
  3204.         // encountered here are enclosed in a type that is a super class of base_type.
  3205.         //
  3206.         if (type_symbol -> ACC_PUBLIC() ||
  3207.             type_symbol -> ACC_PROTECTED() ||
  3208.             ((! type_symbol -> ACC_PRIVATE()) &&
  3209.              (super_type -> ContainingPackage() == base_type -> ContainingPackage())))
  3210.         {
  3211.             NameSymbol *name_symbol = type_symbol -> Identity();
  3212.             TypeShadowSymbol *shadow = base_expanded_table.FindTypeShadowSymbol(name_symbol);
  3213.  
  3214.             if (! shadow)
  3215.                 base_expanded_table.InsertTypeShadowSymbol(type_symbol);
  3216.             else if (shadow -> type_symbol -> owner != base_type)
  3217.             {
  3218.                 shadow -> AddConflict(type_symbol);
  3219.  
  3220.                 if (type_symbol -> owner != super_type) // main type doesn't override all other fields? process conflicts.
  3221.                 {
  3222.                     for (int k = 0; k < type_shadow_symbol -> NumConflicts(); k++)
  3223.                         shadow -> AddConflict(type_shadow_symbol -> Conflict(k));
  3224.                 }
  3225.             }
  3226.             //
  3227.             // TODO: maybe? if base_type is a nested type check if a type with the same
  3228.             //       name appears in one of the enclosed lexical scopes. If so, add 
  3229.             //       it to the shadow!
  3230.             //
  3231.         }
  3232.     }
  3233.  
  3234.     return;
  3235. }
  3236.  
  3237.  
  3238. void Semantic::AddInheritedFields(TypeSymbol *base_type, TypeSymbol *super_type)
  3239. {
  3240.     ExpandedFieldTable &base_expanded_table = *(base_type -> expanded_field_table),
  3241.                        &super_expanded_table = *(super_type -> expanded_field_table);
  3242.  
  3243.     for (int i = 0; i < super_expanded_table.symbol_pool.Length(); i++)
  3244.     {
  3245.         VariableShadowSymbol *variable_shadow_symbol = super_expanded_table.symbol_pool[i];
  3246.         VariableSymbol *variable_symbol = variable_shadow_symbol -> variable_symbol;
  3247.         //
  3248.         // Note that since all fields in an interface are implicitly public, all other fields
  3249.         // encountered here are enclosed in a type that is a super class of base_type.
  3250.         //
  3251.         if (variable_symbol -> ACC_PUBLIC() ||
  3252.             variable_symbol -> ACC_PROTECTED() ||
  3253.             ((! variable_symbol -> ACC_PRIVATE()) &&
  3254.              (super_type -> ContainingPackage() == base_type -> ContainingPackage())))
  3255.         {
  3256.             NameSymbol *name_symbol = variable_symbol -> Identity();
  3257.             VariableShadowSymbol *shadow = base_expanded_table.FindVariableShadowSymbol(name_symbol);
  3258.  
  3259.             if (! shadow)
  3260.                 base_expanded_table.InsertVariableShadowSymbol(variable_symbol);
  3261.             else if (shadow -> variable_symbol -> owner != base_type)
  3262.             {
  3263.                 shadow -> AddConflict(variable_symbol);
  3264.  
  3265.                 if (variable_symbol -> owner != super_type) // main variable doesn't override all other fields? process conflicts.
  3266.                 {
  3267.                     for (int k = 0; k < variable_shadow_symbol -> NumConflicts(); k++)
  3268.                         shadow -> AddConflict(variable_shadow_symbol -> Conflict(k));
  3269.                 }
  3270.             }
  3271.         }
  3272.     }
  3273.  
  3274.     return;
  3275. } 
  3276.  
  3277.  
  3278. void Semantic::AddInheritedMethods(TypeSymbol *base_type, TypeSymbol *super_type, LexStream::TokenIndex tok)
  3279. {
  3280.     ExpandedMethodTable &base_expanded_table = *(base_type -> expanded_method_table),
  3281.                         &super_expanded_table = *(super_type -> expanded_method_table);
  3282.  
  3283.     for (int k = 0; k < super_expanded_table.symbol_pool.Length(); k++)
  3284.     {
  3285.         MethodShadowSymbol *method_shadow_symbol = super_expanded_table.symbol_pool[k];
  3286.         MethodSymbol *method = method_shadow_symbol -> method_symbol;
  3287.  
  3288.         //
  3289.         // Note that since all fields in an interface are implicitly
  3290.         // public, all other fields encountered here are enclosed in a
  3291.         // type that is a super class of base_type. 
  3292.         //
  3293.         if (method -> ACC_PUBLIC() ||
  3294.             method -> ACC_PROTECTED() ||
  3295.             ((! method -> ACC_PRIVATE()) && 
  3296.              (super_type -> ContainingPackage() == base_type -> ContainingPackage())))
  3297.         {
  3298.             MethodShadowSymbol *base_method_shadow =
  3299.                   base_expanded_table.FindMethodShadowSymbol(method -> Identity());
  3300.             if (! base_method_shadow)
  3301.                  base_expanded_table.InsertMethodShadowSymbol(method);
  3302.             else
  3303.             {
  3304.                 MethodShadowSymbol *shadow = base_expanded_table.FindOverloadMethodShadow(method, (Semantic *) this, tok);
  3305.  
  3306.                 if (! shadow)
  3307.                      base_expanded_table.Overload(base_method_shadow, method);
  3308.                 else
  3309.                 {
  3310.                     shadow -> AddConflict(method);
  3311.  
  3312.                     //
  3313.                     // If main method in question does not override all other methods,
  3314.                     // add all other conflicting methods.
  3315.                     //
  3316.                     if (method -> containing_type != super_type)
  3317.                     {
  3318.                         for (int i = 0; i < method_shadow_symbol -> NumConflicts(); i++)
  3319.                             shadow -> AddConflict(method_shadow_symbol -> Conflict(i));
  3320.                     }
  3321.                 }
  3322.             }
  3323.         }
  3324.         else if (! (method -> ACC_PRIVATE() || method -> IsSynthetic())) // Not amethod with default access from another package?
  3325.         {
  3326.             MethodShadowSymbol *base_method_shadow = base_expanded_table.FindMethodShadowSymbol(method -> Identity());
  3327.  
  3328.             if (base_method_shadow)
  3329.             {
  3330.                 MethodShadowSymbol *shadow = base_expanded_table.FindOverloadMethodShadow(method, (Semantic *) this, tok);
  3331.  
  3332.                 if (shadow)
  3333.                 {
  3334.                     LexStream::TokenIndex left_tok,
  3335.                                           right_tok;
  3336.  
  3337.                     if (ThisType() == base_type)
  3338.                     {
  3339.                         AstMethodDeclaration *method_declaration = (AstMethodDeclaration *)
  3340.                                                                     shadow -> method_symbol -> method_or_constructor_declaration;
  3341.                         AstMethodDeclarator *method_declarator = method_declaration -> method_declarator;
  3342.  
  3343.                         left_tok = method_declarator -> LeftToken();
  3344.                         right_tok = method_declarator -> RightToken();
  3345.                     }
  3346.                     else
  3347.                     {
  3348.                         AstInterfaceDeclaration *interface_declaration = ThisType() -> declaration -> InterfaceDeclarationCast();
  3349.                         AstClassDeclaration *class_declaration = ThisType() -> declaration -> ClassDeclarationCast();
  3350.                         if (interface_declaration)
  3351.                         {
  3352.                             left_tok = right_tok = interface_declaration -> identifier_token;
  3353.                         }
  3354.                         else if (class_declaration)
  3355.                         {
  3356.                             left_tok = right_tok = class_declaration -> identifier_token;
  3357.                         }
  3358.                         else
  3359.                         {
  3360.                             AstClassInstanceCreationExpression *class_creation = ThisType() -> declaration
  3361.                                                                                             -> ClassInstanceCreationExpressionCast();
  3362. assert(class_creation);
  3363.                             left_tok = class_creation -> class_type -> LeftToken();
  3364.                             right_tok = class_creation -> class_type -> RightToken();
  3365.                         }
  3366.                     }
  3367.  
  3368.                     ReportSemError(SemanticError::DEFAULT_METHOD_NOT_OVERRIDDEN,
  3369.                                    left_tok,
  3370.                                    right_tok,
  3371.                                    method -> Header((Semantic *) this, tok),
  3372.                                    base_type -> ContainingPackage() -> PackageName(),
  3373.                                    base_type -> ExternalName(),
  3374.                                    super_type -> ContainingPackage() -> PackageName(),
  3375.                                    super_type -> ExternalName());
  3376.                 }
  3377.             }
  3378.         }
  3379.     }
  3380.  
  3381.     return;
  3382. } 
  3383.  
  3384.  
  3385. void Semantic::ComputeTypesClosure(TypeSymbol *type, LexStream::TokenIndex tok)
  3386. {
  3387.     type -> expanded_type_table = new ExpandedTypeTable();
  3388.  
  3389.     TypeSymbol *super_class = type -> super;
  3390.     if (super_class)
  3391.     {
  3392.         if (! super_class -> expanded_type_table)
  3393.             ComputeTypesClosure(super_class, tok);
  3394.     }
  3395.  
  3396.     for (int j = 0; j < type -> NumInterfaces(); j++)
  3397.     {
  3398.         TypeSymbol *interf = type -> Interface(j);
  3399.         if (! interf -> expanded_type_table)
  3400.             ComputeTypesClosure(interf, tok);
  3401.     }
  3402.  
  3403.     if (! type -> NestedTypesProcessed())
  3404.         type -> ProcessNestedTypeSignatures((Semantic *) this, tok);
  3405.     for (int i = 0; i < type -> NumTypeSymbols(); i++)
  3406.     {
  3407.         if (! type -> TypeSym(i) -> Bad())
  3408.             type -> expanded_type_table -> InsertTypeShadowSymbol(type -> TypeSym(i));
  3409.     }
  3410.     if (super_class)
  3411.         AddInheritedTypes(type, super_class);
  3412.     for (int k = 0; k < type -> NumInterfaces(); k++)
  3413.         AddInheritedTypes(type, type -> Interface(k));
  3414.     type -> expanded_type_table -> CompressSpace();
  3415.  
  3416.     return;
  3417. }
  3418.  
  3419.  
  3420. void Semantic::ComputeFieldsClosure(TypeSymbol *type, LexStream::TokenIndex tok)
  3421. {
  3422.     type -> expanded_field_table = new ExpandedFieldTable();
  3423.  
  3424.     TypeSymbol *super_class = type -> super;
  3425.     if (super_class)
  3426.     {
  3427.         if (! super_class -> expanded_field_table)
  3428.             ComputeFieldsClosure(super_class, tok);
  3429.     }
  3430.  
  3431.     for (int j = 0; j < type -> NumInterfaces(); j++)
  3432.     {
  3433.         TypeSymbol *interf = type -> Interface(j);
  3434.         if (! interf -> expanded_field_table)
  3435.             ComputeFieldsClosure(interf, tok);
  3436.     }
  3437.  
  3438. assert(type -> FieldMembersProcessed());
  3439.  
  3440.     for (int i = 0; i < type -> NumVariableSymbols(); i++)
  3441.     {
  3442.         VariableSymbol *variable = type -> VariableSym(i);
  3443.         type -> expanded_field_table -> InsertVariableShadowSymbol(variable);
  3444.     }
  3445.  
  3446.     //
  3447.     // As the type Object which is the super type of all interfaces does
  3448.     // not contain any field declarations, we don't have to do any special
  3449.     // check here as we have to when computing method closures.
  3450.     //
  3451.     if (super_class) 
  3452.         AddInheritedFields(type, super_class);
  3453.     for (int k = 0; k < type -> NumInterfaces(); k++)
  3454.         AddInheritedFields(type, type -> Interface(k));
  3455.     type -> expanded_field_table -> CompressSpace();
  3456.  
  3457.     return;
  3458. }
  3459.  
  3460.  
  3461. void Semantic::ComputeMethodsClosure(TypeSymbol *type, LexStream::TokenIndex tok)
  3462. {
  3463.     type -> expanded_method_table = new ExpandedMethodTable();
  3464.  
  3465.     TypeSymbol *super_class = type -> super;
  3466.     if (super_class)
  3467.     {
  3468.         if (! super_class -> expanded_method_table)
  3469.             ComputeMethodsClosure(super_class, tok);
  3470.     }
  3471.  
  3472.     for (int j = 0; j < type -> NumInterfaces(); j++)
  3473.     {
  3474.         TypeSymbol *interf = type -> Interface(j);
  3475.  
  3476.         if (! interf -> expanded_method_table)
  3477.             ComputeMethodsClosure(interf, tok);
  3478.     }
  3479.  
  3480. assert(type -> MethodMembersProcessed());
  3481.  
  3482.     for (int i = 0; i < type -> NumMethodSymbols(); i++)
  3483.     {
  3484.         MethodSymbol *method = type -> MethodSym(i);
  3485.         //
  3486.         // If the method in question is neither a constructor nor an
  3487.         // initializer, then ...
  3488.         //        if (method -> Identity() != control.init_name_symbol &&
  3489.         //            method -> Identity() != control.block_init_name_symbol &&
  3490.         //            method -> Identity() != control.clinit_name_symbol)
  3491.         //
  3492.         if (*(method -> Name()) != U_LESS)
  3493.         {
  3494.             type -> expanded_method_table -> Overload(method);
  3495.         }
  3496.     }
  3497.     if (super_class && (! type -> ACC_INTERFACE()))
  3498.         AddInheritedMethods(type, super_class, tok);
  3499.     for (int k = 0; k < type -> NumInterfaces(); k++)
  3500.         AddInheritedMethods(type, type -> Interface(k), tok);
  3501.     if (type -> ACC_INTERFACE()) // the super class is Object
  3502.         AddInheritedMethods(type, control.Object(), tok);
  3503.     type -> expanded_method_table -> CompressSpace();
  3504.  
  3505.     return;
  3506. }
  3507.  
  3508.  
  3509. void Semantic::ProcessFormalParameters(BlockSymbol *block, AstMethodDeclarator *method_declarator)
  3510. {
  3511.     for (int i = 0; i < method_declarator -> NumFormalParameters(); i++)
  3512.     {
  3513.         AstFormalParameter *parameter = method_declarator -> FormalParameter(i);
  3514.         AstArrayType *array_type = parameter -> type -> ArrayTypeCast();
  3515.         Ast *actual_type = (array_type ? array_type -> type : parameter -> type);
  3516.  
  3517.         if ((! control.option.one_one) && parameter -> NumParameterModifiers() > 0)
  3518.         {
  3519.             ReportSemError(SemanticError::ONE_ONE_FEATURE,
  3520.                            parameter -> ParameterModifier(0) -> LeftToken(),
  3521.                            parameter -> ParameterModifier(0) -> RightToken());
  3522.         }
  3523.         AccessFlags access_flags = ProcessFormalModifiers(parameter);
  3524.  
  3525.         AstPrimitiveType *primitive_type = actual_type -> PrimitiveTypeCast();
  3526.         TypeSymbol *parm_type = (primitive_type ? FindPrimitiveType(primitive_type) : MustFindType(actual_type));
  3527.  
  3528.         AstVariableDeclaratorId *name = parameter -> variable_declarator_name;
  3529.         NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(name -> identifier_token);
  3530.         VariableSymbol *symbol = block -> FindVariableSymbol(name_symbol);
  3531.         if (symbol)
  3532.         {
  3533.             ReportSemError(SemanticError::DUPLICATE_FORMAL_PARAMETER,
  3534.                            name -> identifier_token,
  3535.                            name -> identifier_token,
  3536.                            name_symbol -> Name());
  3537.         }
  3538.         else symbol = block -> InsertVariableSymbol(name_symbol);
  3539.  
  3540.         int num_dimensions = (array_type ? array_type -> NumBrackets() : 0) + name -> NumBrackets();
  3541.         if (num_dimensions == 0)
  3542.              symbol -> SetType(parm_type);
  3543.         else symbol -> SetType(parm_type -> GetArrayType((Semantic *) this, num_dimensions));
  3544.         symbol -> SetFlags(access_flags);
  3545.         symbol -> MarkComplete();
  3546.  
  3547.         parameter -> parameter_symbol = symbol;
  3548.     }
  3549.  
  3550.     return;
  3551. }
  3552.  
  3553.  
  3554. void Semantic::ProcessMethodDeclaration(AstMethodDeclaration *method_declaration)
  3555. {
  3556.     TypeSymbol *this_type = ThisType();
  3557.     AccessFlags access_flags = (this_type -> ACC_INTERFACE()
  3558.                                            ? ProcessAbstractMethodModifiers(method_declaration)
  3559.                                            : ProcessMethodModifiers(method_declaration));
  3560.  
  3561.     //
  3562.     // TODO: File Query Sun on that one. We no longer explicitly mark such methods as final
  3563.     //       as it appears that some tools expect these methods to remain unmarked.
  3564.     //
  3565.     //
  3566.     // A private method and all methods declared in a final class are implicitly final.
  3567.     //
  3568.     // if (access_flags.ACC_PRIVATE() || this_type -> ACC_FINAL())
  3569.     //    access_flags.SetACC_FINAL();
  3570.     //
  3571.  
  3572.     //
  3573.     // A method enclosed in an inner type may not be declared static.
  3574.     //
  3575.     if (access_flags.ACC_STATIC() && this_type -> IsInner())
  3576.     {
  3577.         AstModifier *modifier = NULL;
  3578.         for (int i = 0; i < method_declaration -> NumMethodModifiers(); i++)
  3579.         {
  3580.             if (method_declaration -> MethodModifier(i) -> kind == Ast::STATIC)
  3581.                 modifier = method_declaration -> MethodModifier(i);
  3582.         }
  3583.  
  3584. assert(modifier);
  3585.         ReportSemError(SemanticError::STATIC_METHOD_IN_INNER_CLASS,
  3586.                        modifier -> modifier_kind_token,
  3587.                        modifier -> modifier_kind_token);
  3588.     }
  3589.  
  3590.     //
  3591.     //
  3592.     //
  3593.     AstArrayType *array_type = method_declaration -> type -> ArrayTypeCast();
  3594.     Ast *actual_type = (array_type ? array_type -> type : method_declaration -> type);
  3595.     AstPrimitiveType *primitive_type = actual_type -> PrimitiveTypeCast();
  3596.     TypeSymbol *method_type = (primitive_type ? FindPrimitiveType(primitive_type) : MustFindType(actual_type));
  3597.  
  3598.     AstMethodDeclarator *method_declarator = method_declaration -> method_declarator;
  3599.     if (method_declarator -> NumBrackets() > 0)
  3600.     {
  3601.         if (method_type == control.void_type)
  3602.              ReportSemError(SemanticError::VOID_ARRAY,
  3603.                             method_declaration -> type -> LeftToken(),
  3604.                             method_declarator -> RightToken());
  3605.         else ReportSemError(SemanticError::OBSOLESCENT_BRACKETS,
  3606.                             method_declarator -> LeftToken(),
  3607.                             method_declarator -> RightToken());
  3608.     }
  3609.  
  3610.     NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(method_declarator -> identifier_token);
  3611.  
  3612.     if (name_symbol == this_type -> Identity())
  3613.     {
  3614.         ReportSemError(SemanticError::METHOD_WITH_CONSTRUCTOR_NAME,
  3615.                        method_declaration -> type -> LeftToken(),
  3616.                        method_declarator -> identifier_token,
  3617.                        name_symbol -> Name());
  3618.     }
  3619.  
  3620.     //
  3621.     // As the body of the method may not have been parsed yet, we estimate a size
  3622.     // for its symbol table based on the number of lines in the body + a margin for one-liners.
  3623.     //
  3624.     AstBlock *block = method_declaration -> method_body -> BlockCast();
  3625.     BlockSymbol *block_symbol = new BlockSymbol(method_declarator -> NumFormalParameters());
  3626.     block_symbol -> max_variable_index = (access_flags.ACC_STATIC() ? 0 : 1);
  3627.     ProcessFormalParameters(block_symbol, method_declarator);
  3628.  
  3629.     MethodSymbol *method = this_type -> FindMethodSymbol(name_symbol);
  3630.  
  3631.     if (! method)
  3632.         method = this_type -> InsertMethodSymbol(name_symbol);
  3633.     else
  3634.     {
  3635.         if (this_type -> FindOverloadMethod(method, method_declarator))
  3636.         {
  3637.             ReportSemError(SemanticError::DUPLICATE_METHOD,
  3638.                            method_declarator -> LeftToken(),
  3639.                            method_declarator -> RightToken(),
  3640.                            name_symbol -> Name(),
  3641.                            this_type -> Name());
  3642.             delete block_symbol;
  3643.             return;
  3644.         }
  3645.  
  3646.         method = this_type -> Overload(method);
  3647.     }
  3648.  
  3649.     int num_dimensions = (method_type == control.void_type
  3650.                                        ? 0
  3651.                                        : (array_type ? array_type -> NumBrackets() : 0) + method_declarator -> NumBrackets());
  3652.     if (num_dimensions == 0)
  3653.          method -> SetType(method_type);
  3654.     else method -> SetType(method_type -> GetArrayType((Semantic *) this, num_dimensions));
  3655.  
  3656.     //
  3657.     // if the method is not static, leave a slot for the "this" pointer.
  3658.     //
  3659.     method -> SetFlags(access_flags);
  3660.     method -> SetContainingType(this_type);
  3661.     method -> SetBlockSymbol(block_symbol);
  3662.     method -> method_or_constructor_declaration = method_declaration;
  3663.     for (int i = 0; i < method_declarator -> NumFormalParameters(); i++)
  3664.     {
  3665.         AstFormalParameter *parameter = method_declarator -> FormalParameter(i);
  3666.         VariableSymbol *symbol = parameter -> parameter_symbol;
  3667.  
  3668.         symbol -> SetOwner(method);
  3669.         symbol -> SetLocalVariableIndex(block_symbol -> max_variable_index++);
  3670.         if (symbol -> Type() == control.long_type || symbol -> Type() == control.double_type)
  3671.             block_symbol -> max_variable_index++;
  3672.         symbol -> declarator = parameter -> variable_declarator_name;
  3673.         method -> AddFormalParameter(symbol);
  3674.     }
  3675.     method -> SetSignature(control);
  3676.  
  3677.     for (int k = 0; k < method_declaration -> NumThrows(); k++)
  3678.     {
  3679.         AstExpression *throw_expression = method_declaration -> Throw(k);
  3680.         TypeSymbol *throw_type = MustFindType(throw_expression);
  3681.         throw_expression -> symbol = throw_type;
  3682.         method -> AddThrows(throw_type);
  3683.     }
  3684.  
  3685.     method_declaration -> method_symbol = method; // save for processing bodies later.
  3686.  
  3687.     if (method -> ACC_ABSTRACT() && (! this_type -> ACC_ABSTRACT()))
  3688.     {
  3689.         ReportSemError(SemanticError::NON_ABSTRACT_TYPE_CONTAINS_ABSTRACT_METHOD,
  3690.                        method_declaration -> LeftToken(),
  3691.                        method_declarator -> identifier_token,
  3692.                        name_symbol -> Name(),
  3693.                        this_type -> Name());
  3694.     }
  3695.  
  3696.     return;
  3697. }
  3698.  
  3699.  
  3700. //
  3701. // Search for simple identifier which is supposed to be a type.
  3702. // If it is not found, issue an error message.
  3703. //
  3704. TypeSymbol *Semantic::FindPrimitiveType(AstPrimitiveType *primitive_type)
  3705. {
  3706.     switch(primitive_type -> kind)
  3707.     {
  3708.         case Ast::INT:
  3709.              return control.int_type;
  3710.         case Ast::DOUBLE:
  3711.              return control.double_type;
  3712.         case Ast::CHAR:
  3713.              return control.char_type;
  3714.         case Ast::LONG:
  3715.              return control.long_type;
  3716.         case Ast::FLOAT:
  3717.              return control.float_type;
  3718.         case Ast::BYTE:
  3719.              return control.byte_type;
  3720.         case Ast::SHORT:
  3721.              return control.short_type;
  3722.         case Ast::BOOLEAN:
  3723.              return control.boolean_type;
  3724.         default:
  3725.              break;
  3726.     }
  3727.  
  3728.     return control.void_type;
  3729. }
  3730.  
  3731.  
  3732. TypeSymbol *Semantic::ImportType(LexStream::TokenIndex identifier_token, NameSymbol *name_symbol)
  3733. {
  3734.     TypeSymbol *type = NULL;
  3735.     PackageSymbol *package = NULL;
  3736.     FileSymbol *file_symbol = NULL;
  3737.  
  3738.     for (int i = 0; i < import_on_demand_packages.Length(); i++)
  3739.     {
  3740.         PackageSymbol *import_package = import_on_demand_packages[i] -> PackageCast();
  3741.  
  3742.         if (import_package)
  3743.         {
  3744.             FileSymbol *symbol = Control::GetFile(import_package, name_symbol, control.option.depend);
  3745.             if (symbol)
  3746.             {
  3747.                 if (! package)
  3748.                 {
  3749.                     file_symbol = symbol;
  3750.                     package = import_package;
  3751.                 }
  3752.                 else
  3753.                 {
  3754.                     ReportSemError(SemanticError::DUPLICATE_ON_DEMAND_IMPORT,
  3755.                                    identifier_token,
  3756.                                    identifier_token,
  3757.                                    name_symbol -> Name(),
  3758.                                    package -> PackageName(),
  3759.                                    import_package -> PackageName());
  3760.                 }
  3761.             }
  3762.         }
  3763.         else
  3764.         {
  3765.             TypeSymbol *import_type = (TypeSymbol *) import_on_demand_packages[i];
  3766.  
  3767.             if (! import_type -> expanded_type_table)
  3768.                 ComputeTypesClosure(import_type, identifier_token);
  3769.             TypeShadowSymbol *type_shadow_symbol = import_type -> expanded_type_table -> FindTypeShadowSymbol(name_symbol);
  3770.             if (type_shadow_symbol)
  3771.                 type = FindTypeInShadow(type_shadow_symbol, identifier_token);
  3772.         }
  3773.     }
  3774.  
  3775.     if (! type)
  3776.     {
  3777.         if (package)
  3778.         {
  3779.             type = package -> FindTypeSymbol(name_symbol);
  3780.             if (! type)
  3781.                  type = ReadType(file_symbol, package, name_symbol, identifier_token);
  3782.             else if (type -> SourcePending())
  3783.                  control.ProcessHeaders(type -> file_symbol);
  3784.         }
  3785.     }
  3786.  
  3787.     if (type && (! (type -> ACC_PUBLIC() || type -> ContainingPackage() == this_package)))
  3788.         ReportTypeInaccessible(identifier_token, identifier_token, type);
  3789.  
  3790.     return type;
  3791. }
  3792.  
  3793.  
  3794. TypeSymbol *Semantic::FindType(LexStream::TokenIndex identifier_token)
  3795. {
  3796.     TypeSymbol *type;
  3797.  
  3798.     NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  3799.  
  3800.     SemanticEnvironment *env;
  3801.     for (env = state_stack.Top(); env; env = env -> previous)
  3802.     {
  3803.         type = env -> symbol_table.FindTypeSymbol(name_symbol);
  3804.         if (type)
  3805.             break;
  3806.  
  3807.         type = env -> Type();
  3808.         if (name_symbol == type -> Identity()) // Recall that a type may not have the same name as one of its enclosing types.
  3809.             break;
  3810.  
  3811.         if (! type -> expanded_type_table)
  3812.             ComputeTypesClosure(type, identifier_token);
  3813.         TypeShadowSymbol *type_shadow_symbol = type -> expanded_type_table -> FindTypeShadowSymbol(name_symbol);
  3814.         if (type_shadow_symbol)
  3815.         {
  3816.             type = FindTypeInShadow(type_shadow_symbol, identifier_token);
  3817.             break;
  3818.         }
  3819.     }
  3820.  
  3821.     if (env) // The type was found in some enclosing environment?
  3822.     {
  3823.         //
  3824.         // If the type is an inherited type, make sure that there is not a
  3825.         // type of the same name within an enclosing lexical scope.
  3826.         //
  3827.         if (type -> owner -> TypeCast() && type -> owner != env -> Type())
  3828.         {
  3829.             for (SemanticEnvironment *env2 = env -> previous; env2; env2 = env2 -> previous)
  3830.             {
  3831.                 TypeSymbol *outer_type = env2 -> symbol_table.FindTypeSymbol(name_symbol); // check local type
  3832.                 if (! outer_type) // if local type not found, check inner type...
  3833.                 {
  3834.                     if (! env2 -> Type() -> expanded_type_table)
  3835.                         ComputeTypesClosure(env2 -> Type(), identifier_token);
  3836.                     TypeShadowSymbol *type_shadow_symbol = env2 -> Type() -> expanded_type_table
  3837.                                                                           -> FindTypeShadowSymbol(name_symbol);
  3838.                     if (type_shadow_symbol)
  3839.                         outer_type = FindTypeInShadow(type_shadow_symbol, identifier_token);
  3840.                 }
  3841.  
  3842.                 //
  3843.                 // If a different type of the same name was found in an enclosing scope.
  3844.                 //
  3845.                 if (outer_type && outer_type != type) 
  3846.                 {
  3847.                     MethodSymbol *method = outer_type -> owner -> MethodCast();
  3848.  
  3849.                     if (method)
  3850.                     {
  3851.                         ReportSemError(SemanticError::INHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_LOCAL,
  3852.                                        identifier_token,
  3853.                                        identifier_token,
  3854.                                        lex_stream -> Name(identifier_token),
  3855.                                        env -> Type() -> ContainingPackage() -> PackageName(),
  3856.                                        env -> Type() -> ExternalName(),
  3857.                                        method -> Name());
  3858.                         break;
  3859.                     }
  3860.                     else
  3861.                     {
  3862.                         ReportSemError(SemanticError::INHERITANCE_AND_LEXICAL_SCOPING_CONFLICT_WITH_MEMBER,
  3863.                                        identifier_token,
  3864.                                        identifier_token,
  3865.                                        lex_stream -> Name(identifier_token),
  3866.                                        env -> Type() -> ContainingPackage() -> PackageName(),
  3867.                                        env -> Type() -> ExternalName(),
  3868.                                        env2 -> Type() -> ContainingPackage() -> PackageName(),
  3869.                                        env2 -> Type() -> ExternalName());
  3870.                         break;
  3871.                     }
  3872.                 }
  3873.             }
  3874.         }
  3875.  
  3876.         return type;
  3877.     }
  3878.  
  3879.     //
  3880.     // check whether or not the type is in the current compilation unit
  3881.     // either because it was declared as a class or interface or it was 
  3882.     // imported by a single-type-import declaration.
  3883.     //
  3884.     for (int i = 0; i < single_type_imports.Length(); i++)
  3885.     {
  3886.         type = single_type_imports[i];
  3887.         if (name_symbol == type -> Identity())
  3888.             return type;
  3889.     }
  3890.  
  3891.     //
  3892.     // If a package was specified in this file (the one we are compiling),
  3893.     // we look for the type requested inside the package in question.
  3894.     // Otherwise, we look for the type requested in the unnamed package.
  3895.     //
  3896.     PackageSymbol *package = (compilation_unit -> package_declaration_opt ? this_package : control.unnamed_package);
  3897.     type = FindSimpleNameType(package, identifier_token);
  3898.  
  3899.     //
  3900.     // Note that a type T contained in a package P is always accessible to all other
  3901.     // types contained in P. I.e., we do not need to perform access check for type.
  3902.     //
  3903.     if (type)
  3904.     {
  3905.         //
  3906.         // If a type T was specified in a source file that is not called T.java
  3907.         // but X.java (where X != T) and we are not currently compiling file X,
  3908.         // issue a warning to alert the user that in some circumstances, this
  3909.         // may not be visible. (i.e., if the file X has not yet been compiled,
  3910.         // then T is invisile as the compiler will only look for T in T.java.)
  3911.         //
  3912.         FileSymbol *file_symbol = type -> file_symbol;
  3913.         if (file_symbol && (type -> Identity() != file_symbol -> Identity()) && (file_symbol != this -> source_file_symbol))
  3914.         {
  3915.             ReportSemError(SemanticError::REFERENCE_TO_TYPE_IN_MISMATCHED_FILE,
  3916.                            identifier_token,
  3917.                            identifier_token,
  3918.                            type -> Name(),
  3919.                            file_symbol -> Name());
  3920.         }
  3921.  
  3922.         return type;
  3923.     }
  3924.  
  3925.     //
  3926.     // check whether or not the type can be imported on demand from 
  3927.     // exactly one package or type.
  3928.     //
  3929.     return ImportType(identifier_token, name_symbol);
  3930. }
  3931.  
  3932.  
  3933. //
  3934. //
  3935. //
  3936. TypeSymbol *Semantic::MustFindType(Ast *name)
  3937. {
  3938.     TypeSymbol *type;
  3939.     LexStream::TokenIndex identifier_token;
  3940.  
  3941.     AstSimpleName *simple_name = name -> SimpleNameCast();
  3942.     if (simple_name)
  3943.     {
  3944.         identifier_token = simple_name -> identifier_token;
  3945.         type = FindType(identifier_token);
  3946.  
  3947.         //
  3948.         // If the type was not found, try to read it again to generate an appropriate error message.
  3949.         //
  3950.         if (! type)
  3951.         {
  3952.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  3953.             PackageSymbol *package = (compilation_unit -> package_declaration_opt ? this_package : control.unnamed_package);
  3954.             FileSymbol *file_symbol = Control::GetFile(package, name_symbol, control.option.depend);
  3955.             type = ReadType(file_symbol, package, name_symbol, identifier_token);
  3956.         }
  3957.         else
  3958.         {
  3959.              TypeAccessCheck(name, type);
  3960.         }
  3961.     }
  3962.     else
  3963.     {
  3964.         AstFieldAccess *field_access = name -> FieldAccessCast();
  3965. assert(field_access);
  3966.         identifier_token = field_access -> identifier_token;
  3967.  
  3968.         Symbol *symbol = ProcessPackageOrType(field_access -> base);
  3969.  
  3970.         type = symbol -> TypeCast();
  3971.         if (type)
  3972.         {
  3973.             TypeNestAccessCheck(field_access -> base);
  3974.             type = MustFindNestedType(type, field_access);
  3975.         }
  3976.         else
  3977.         {
  3978.             PackageSymbol *package = symbol -> PackageCast();
  3979.             if (package -> directory.Length() == 0)
  3980.             {
  3981.                 ReportSemError(SemanticError::PACKAGE_NOT_FOUND,
  3982.                                field_access -> base -> LeftToken(),
  3983.                                field_access -> base -> RightToken(),
  3984.                                package -> PackageName());
  3985.             }
  3986.             NameSymbol *name_symbol = (NameSymbol *) lex_stream -> NameSymbol(identifier_token);
  3987.             type = package -> FindTypeSymbol(name_symbol);
  3988.             if (! type)
  3989.             {
  3990.                 FileSymbol *file_symbol = Control::GetFile(package, name_symbol, control.option.depend);
  3991.                 type = ReadType(file_symbol, package, name_symbol, identifier_token);
  3992.             }
  3993.             else
  3994.             {
  3995.                 if (type -> SourcePending())
  3996.                     control.ProcessHeaders(type -> file_symbol);
  3997.                 TypeAccessCheck(name, type);
  3998.             }
  3999.         }
  4000.     }
  4001.  
  4002.     //
  4003.     // Establish a dependence from base_type to a type that it "must find".
  4004.     //
  4005.     AddDependence(ThisType(), type, identifier_token);
  4006.  
  4007.     return type;
  4008. }
  4009.  
  4010.  
  4011. void Semantic::ProcessInterface(AstExpression *name)
  4012. {
  4013.     TypeSymbol *interf = MustFindType(name);
  4014. assert(! interf -> SourcePending());
  4015.  
  4016.     if (! interf -> ACC_INTERFACE())
  4017.     {
  4018.         if (! interf -> Bad())
  4019.         {
  4020.             ReportSemError(SemanticError::NOT_AN_INTERFACE,
  4021.                            name -> LeftToken(),
  4022.                            name -> RightToken(),
  4023.                            interf -> ContainingPackage() -> PackageName(),
  4024.                            interf -> ExternalName());
  4025.         }
  4026.     }
  4027.     else
  4028.     {
  4029.         TypeSymbol *this_type = ThisType();
  4030.         int k;
  4031.         for (k = 0; k < this_type -> NumInterfaces(); k++)
  4032.             if (this_type -> Interface(k) == interf)
  4033.                 break;
  4034.         if (k < this_type -> NumInterfaces())
  4035.         {
  4036.             ReportSemError(SemanticError::DUPLICATE_INTERFACE,
  4037.                            name -> LeftToken(),
  4038.                            name -> RightToken(),
  4039.                            interf -> ContainingPackage() -> PackageName(),
  4040.                            interf -> ExternalName(),
  4041.                            this_type -> ExternalName());
  4042.         }
  4043.         else
  4044.         {
  4045.             this_type -> AddInterface(interf);
  4046.         }
  4047.     }
  4048.  
  4049.     return;
  4050. }
  4051.  
  4052.  
  4053. void Semantic::InitializeVariable(AstFieldDeclaration *field_declaration, Tuple<VariableSymbol *> &finals)
  4054. {
  4055.     ThisMethod() = NULL;
  4056.  
  4057.     for (int i = 0; i < field_declaration -> NumVariableDeclarators(); i++)
  4058.     {
  4059.         AstVariableDeclarator *variable_declarator = field_declaration -> VariableDeclarator(i);
  4060.  
  4061.         if (ThisVariable() = variable_declarator -> symbol)
  4062.         {
  4063.             if (variable_declarator -> variable_initializer_opt)
  4064.             {
  4065.                 variable_declarator -> pending = true;
  4066.  
  4067.                 int start_num_errors = NumErrors();
  4068.  
  4069.                 ProcessVariableInitializer(variable_declarator);
  4070.                 if (NumErrors() == start_num_errors)
  4071.                      DefiniteVariableInitializer(variable_declarator, finals);
  4072.                 else variable_declarator -> symbol -> MarkDefinitelyAssigned(); // assume variable is assigned
  4073.  
  4074.                 variable_declarator -> pending = false;
  4075.             }
  4076.             ThisVariable() -> MarkComplete();
  4077.         }
  4078.     }
  4079.  
  4080.     return;
  4081. }
  4082.  
  4083.  
  4084. inline void Semantic::ProcessInitializer(AstBlock *initializer_block, AstBlock *block_body,
  4085.                                          MethodSymbol *init_method, Tuple<VariableSymbol *> &finals)
  4086. {
  4087.     ThisVariable() = NULL;
  4088.     ThisMethod() = init_method;
  4089.  
  4090.     LocalBlockStack().Push(initializer_block);
  4091.     LocalSymbolTable().Push(init_method -> block_symbol -> Table());
  4092.  
  4093.     int start_num_errors = NumErrors();
  4094.  
  4095.     AstConstructorBlock *constructor_block = block_body -> ConstructorBlockCast();
  4096.     if (constructor_block)
  4097.     {
  4098. assert(constructor_block -> explicit_constructor_invocation_opt);
  4099.         ReportSemError(SemanticError::MISPLACED_EXPLICIT_CONSTRUCTOR_INVOCATION,
  4100.                        constructor_block -> explicit_constructor_invocation_opt -> LeftToken(),
  4101.                        constructor_block -> explicit_constructor_invocation_opt -> RightToken());
  4102.     }
  4103.  
  4104.     ProcessBlock(block_body);
  4105.  
  4106.     if (NumErrors() == start_num_errors)
  4107.         DefiniteBlockInitializer(block_body, LocalBlockStack().max_size, finals);
  4108.  
  4109.     //
  4110.     // If an enclosed block has a higher max_variable_index than the current block,
  4111.     // update max_variable_index in the current_block, accordingly.
  4112.     //
  4113.     if (init_method -> block_symbol -> max_variable_index < LocalBlockStack().TopMaxEnclosedVariableIndex())
  4114.         init_method -> block_symbol -> max_variable_index = LocalBlockStack().TopMaxEnclosedVariableIndex();
  4115.  
  4116.     LocalBlockStack().Pop();
  4117.     LocalSymbolTable().Pop();
  4118.  
  4119.     return;
  4120. }
  4121.  
  4122.  
  4123. void Semantic::ProcessStaticInitializers(AstClassBody *class_body)
  4124. {
  4125.     if (class_body -> NumStaticInitializers() > 0 || class_body -> NumClassVariables() > 0)
  4126.     {
  4127.         TypeSymbol *this_type = ThisType();
  4128.  
  4129.         MethodSymbol *init_method = this_type -> InsertMethodSymbol(control.clinit_name_symbol);
  4130.  
  4131.         init_method -> SetType(control.void_type);
  4132.         init_method -> SetACC_FINAL();
  4133.         init_method -> SetACC_STATIC();
  4134.         init_method -> SetContainingType(this_type);
  4135.         init_method -> SetBlockSymbol(new BlockSymbol(0)); // the symbol table associated with this block will contain no element
  4136.         init_method -> block_symbol -> max_variable_index = 0;
  4137.         init_method -> SetSignature(control);
  4138.  
  4139.         this_type -> static_initializer_method = init_method;
  4140.  
  4141.         AstBlock *initializer_block = compilation_unit -> ast_pool -> GenBlock();
  4142.         initializer_block -> left_brace_token  = class_body -> left_brace_token;
  4143.         initializer_block -> right_brace_token = class_body -> left_brace_token;
  4144.         initializer_block -> block_symbol = init_method -> block_symbol;
  4145.         initializer_block -> nesting_level = LocalBlockStack().Size();
  4146.  
  4147.         LocalBlockStack().max_size = 0;
  4148.  
  4149.         //
  4150.         // Compute the set of final variables declared by the user in this type.
  4151.         //
  4152.         Tuple<VariableSymbol *> finals(this_type -> NumVariableSymbols());
  4153.         for (int l = 0; l < this_type -> NumVariableSymbols(); l++)
  4154.         {
  4155.             VariableSymbol *variable_symbol = this_type -> VariableSym(l);
  4156.             if (variable_symbol -> ACC_FINAL())
  4157.                 finals.Next() = variable_symbol;
  4158.         }
  4159.  
  4160.         //
  4161.         // The static initializers and class variable initializers are executed in textual order... 8.5
  4162.         //
  4163.         int j,
  4164.             k;
  4165.         for (j = 0, k = 0; j < class_body -> NumClassVariables() && k < class_body -> NumStaticInitializers(); )
  4166.         {
  4167.             //
  4168.             // Note that since there cannot be any overlap in the
  4169.             // declarations, we can use either location position.
  4170.             // The RightToken of the field declaration is used because it
  4171.             // does not have to be computed (it is the terminating semicolon).
  4172.             // Similarly, the LeftToken of the static initializer is used
  4173.             // because it is the initial "static" keyword that marked the initializer.
  4174.             //
  4175.             //    if (class_body -> InstanceVariables(j) -> RightToken() < class_body -> Block(k) -> LeftToken())
  4176.             //
  4177.             if (class_body -> ClassVariable(j) -> semicolon_token < class_body -> StaticInitializer(k) -> static_token)
  4178.             {
  4179.                 InitializeVariable(class_body -> ClassVariable(j), finals);
  4180.                 j++;
  4181.             }
  4182.             else
  4183.             {
  4184.                 AstBlock *block_body = class_body -> StaticInitializer(k) -> block;
  4185.  
  4186.                 //
  4187.                 // The first block that is the body of an initializer is reachable
  4188.                 // A subsequent block is reachable iff its predecessor can complete
  4189.                 // normally
  4190.                 //
  4191.                 block_body -> is_reachable = (k == 0
  4192.                                                  ? true
  4193.                                                  : class_body -> StaticInitializer(k - 1) -> block -> can_complete_normally);
  4194.  
  4195.                 ProcessInitializer(initializer_block, block_body, init_method, finals);
  4196.                 k++;
  4197.             }
  4198.         }
  4199.         for (; j < class_body -> NumClassVariables(); j++)
  4200.             InitializeVariable(class_body -> ClassVariable(j), finals);
  4201.         for (; k < class_body -> NumStaticInitializers(); k++)
  4202.         {
  4203.             AstBlock *block_body = class_body -> StaticInitializer(k) -> block;
  4204.  
  4205.             //
  4206.             // The first block that is the body of an initializer is reachable
  4207.             // A subsequent block is reachable iff its predecessor can complete
  4208.             // normally
  4209.             //
  4210.             block_body -> is_reachable = (k == 0
  4211.                                              ? true
  4212.                                              : class_body -> StaticInitializer(k - 1) -> block -> can_complete_normally);
  4213.  
  4214.             ProcessInitializer(initializer_block, block_body, init_method, finals);
  4215.         }
  4216.  
  4217.         init_method -> max_block_depth = LocalBlockStack().max_size;
  4218.         init_method -> block_symbol -> CompressSpace(); // space optimization
  4219.  
  4220.         //
  4221.         // Check that all static final variables have been initialized by now.
  4222.         // If not, issue an error and assume they are.
  4223.         //
  4224.         for (int i = 0; i < finals.Length(); i++)
  4225.         {
  4226.             if (finals[i] -> ACC_STATIC() && (! finals[i] -> IsDefinitelyAssigned()))
  4227.             {
  4228.                 ReportSemError(SemanticError::UNINITIALIZED_STATIC_FINAL_VARIABLE,
  4229.                                finals[i] -> declarator -> LeftToken(),
  4230.                                finals[i] -> declarator -> RightToken());
  4231.                 finals[i] -> MarkDefinitelyAssigned();
  4232.             }
  4233.         }
  4234.  
  4235. // STG:
  4236. //        delete initializer_block;
  4237.     }
  4238.  
  4239.     return;
  4240. }
  4241.  
  4242.  
  4243. void Semantic::ProcessBlockInitializers(AstClassBody *class_body)
  4244. {
  4245.     TypeSymbol *this_type = ThisType();
  4246.  
  4247.     //
  4248.     // Compute the set of final variables declared by the user in this type.
  4249.     //
  4250.     Tuple<VariableSymbol *> finals(this_type -> NumVariableSymbols());
  4251.     for (int i = 0; i < this_type -> NumVariableSymbols(); i++)
  4252.     {
  4253.         VariableSymbol *variable_symbol = this_type -> VariableSym(i);
  4254.         if (variable_symbol -> ACC_FINAL())
  4255.             finals.Next() = variable_symbol;
  4256.     }
  4257.  
  4258.     //
  4259.     // Initialization code is executed by every constructor, just after the
  4260.     // superclass constructor is called, in textual order along with any
  4261.     // instance variable initializations.
  4262.     //
  4263.     if (class_body -> NumBlocks() == 0)
  4264.     {
  4265.         for (int j = 0; j < class_body -> NumInstanceVariables(); j++)
  4266.             InitializeVariable(class_body -> InstanceVariable(j), finals);
  4267.     }
  4268.     else
  4269.     {
  4270.         MethodSymbol *init_method = this_type -> InsertMethodSymbol(control.block_init_name_symbol);
  4271.         init_method -> SetType(control.void_type);
  4272.         init_method -> SetACC_FINAL();
  4273.         init_method -> SetACC_PRIVATE();
  4274.         init_method -> SetContainingType(this_type);
  4275.         init_method -> SetBlockSymbol(new BlockSymbol(0));  // the symbol table associated with this block will contain no element
  4276.         init_method -> block_symbol -> max_variable_index = 1;
  4277.         init_method -> SetSignature(control);
  4278.  
  4279.         //
  4280.         // Compute the set of constructors whose bodies do not start with 
  4281.         // an explicit this call.
  4282.         //
  4283.         for (int i = 0; i < class_body -> NumConstructors(); i++)
  4284.         {
  4285.             MethodSymbol *method = class_body -> Constructor(i) -> constructor_symbol;
  4286.             if (method)
  4287.             {
  4288.                 AstConstructorBlock *constructor_block = class_body -> Constructor(i) -> constructor_body;
  4289.                 if (! (constructor_block -> explicit_constructor_invocation_opt &&
  4290.                        constructor_block -> explicit_constructor_invocation_opt -> ThisCallCast()))
  4291.                 init_method -> AddInitializerConstructor(method);
  4292.             }
  4293.         }
  4294.  
  4295.         this_type -> block_initializer_method = init_method;
  4296.  
  4297.         AstBlock *initializer_block = compilation_unit -> ast_pool -> GenBlock();
  4298.         initializer_block -> left_brace_token  = class_body -> left_brace_token;
  4299.         initializer_block -> right_brace_token = class_body -> left_brace_token;
  4300.         initializer_block -> block_symbol = init_method -> block_symbol;
  4301.         initializer_block -> nesting_level = LocalBlockStack().Size();
  4302.  
  4303.         LocalBlockStack().max_size = 0;
  4304.  
  4305.         int j,
  4306.             k;
  4307.         for (j = 0, k = 0; j < class_body -> NumInstanceVariables() && k < class_body -> NumBlocks(); )
  4308.         {
  4309.             //
  4310.             // Note that since there cannot be any overlap in the
  4311.             // declarations, we can use either location position.
  4312.             // The RightToken of the field declaration is used because it
  4313.             // does not have to be computed (it is the terminating semicolon).
  4314.             // Similarly, the LeftToken of the block initializer is used
  4315.             // because it is the initial "{".
  4316.             //
  4317.             //    if (class_body -> InstanceVariable(j) -> RightToken() < class_body -> Blocks(k) -> LeftToken())
  4318.             //
  4319.             if (class_body -> InstanceVariable(j) -> semicolon_token < class_body -> Block(k) -> left_brace_token)
  4320.             {
  4321.                 InitializeVariable(class_body -> InstanceVariable(j), finals);
  4322.                 j++;
  4323.             }
  4324.             else
  4325.             {
  4326.                 AstBlock *block_body = class_body -> Block(k);
  4327.  
  4328.                 //
  4329.                 // The first block that is the body of an initializer is reachable
  4330.                 // A subsequent block is reachable iff its predecessor can complete
  4331.                 // normally
  4332.                 //
  4333.                 block_body -> is_reachable = (k == 0 ? true : class_body -> Block(k - 1) -> can_complete_normally);
  4334.  
  4335.                 ProcessInitializer(initializer_block, block_body, init_method, finals);
  4336.                 k++;
  4337.             }
  4338.         }
  4339.         for (; j < class_body -> NumInstanceVariables(); j++)
  4340.             InitializeVariable(class_body -> InstanceVariable(j), finals);
  4341.         for (; k < class_body -> NumBlocks(); k++)
  4342.         {
  4343.             AstBlock *block_body = class_body -> Block(k);
  4344.  
  4345.             //
  4346.             // The first block that is the body of an initializer is reachable
  4347.             // A subsequent block is reachable iff its predecessor can complete
  4348.             // normally
  4349.             //
  4350.             block_body -> is_reachable = (k == 0 ? true : class_body -> Block(k - 1) -> can_complete_normally);
  4351.  
  4352.             ProcessInitializer(initializer_block, block_body, init_method, finals);
  4353.         }
  4354.  
  4355.         init_method -> max_block_depth = LocalBlockStack().max_size;
  4356.         init_method -> block_symbol -> CompressSpace(); // space optimization
  4357.  
  4358.         //
  4359.         // Note that unlike the case of static fields. We do not ensure here that
  4360.         // each final instance variable has been initialized at this point, because
  4361.         // the user may chose instead to initialize such a final variable in every
  4362.         // constructor instead. See body.cpp
  4363.         //
  4364.  
  4365. // STG:
  4366. //        delete initializer_block;
  4367.     }
  4368.  
  4369.     return;
  4370. }
  4371.